mirror of
https://github.com/badlogic/pi-mono.git
synced 2026-11-05 23:37:25 +00:00
2a32a605a9
A sandbox is a new env type (`type: "gondolin"`): a long-lived Gondolin micro-VM on an SSH environment, with listed host folders and an HTTP(S) host allowlist. The worker reaches it over SSH to the host, where p2's launcher (plugins/envs/sandbox: native, or Docker when the host's Node/QEMU are too old) runs pi-env's daemon inside the VM, so tools, workspace, terminals, uploads and MCP work unchanged. Names outside the allowlist are refused before the host resolves them. Conversations working in a sandbox cannot leave it: location tools, subagent spawn/configure, AgentLocations.move, the terminal tool, and one-shot agents (which now inherit their caller's own location) all keep them there; only the owner's Relocate moves a session out, after a confirmation. conversationConfinement() exposes it to plugins. Owner-only management in the Envs sheet: sandboxes listed under their host, host test reports sandbox support, create/edit/start/stop/restart/test, lock icons in the top bar and sidebar. Tests in test/p2/sandboxes.test.ts (real VM cases with P2_TEST_GONDOLIN=1) and ui-sandboxes.test.ts; docs in docs/remote-envs.md.
59 lines
3 KiB
TypeScript
59 lines
3 KiB
TypeScript
// The terminals plugin's worker facet: the agent's `terminal` tool, calling the server's `AgentTerminals` as this
|
|
// session's worker, at the calling conversation's location. It follows the code mode switch as MCP tools do: for
|
|
// scripts while code mode is on, loaded with `tool_search` while it is off.
|
|
|
|
import type { Extension } from "@earendil-works/pi-durable";
|
|
import { type Context, type Ctx, contribute, defineFacet, expectVariant } from "@p2/app/v1";
|
|
import { ExtensionSwitches } from "@p2/app/v1/node";
|
|
import { Extensions, harnessOf, workerOf } from "@p2/app/v1/worker";
|
|
import { AgentTerminals } from "./contract.ts";
|
|
import {
|
|
createTerminalExtension,
|
|
TERMINAL_EXTENSION,
|
|
type TerminalBackend,
|
|
type TerminalCaller,
|
|
type TerminalReach,
|
|
} from "./tool.ts";
|
|
|
|
/** The code mode plugin's extension: its switch is on while the `codemode` setting is, absent without the plugin. */
|
|
const CODEMODE_EXTENSION = "codemode";
|
|
|
|
export default defineFacet((host) => {
|
|
contribute(host, "p2.terminal-tools", (self) => {
|
|
const harness = harnessOf(self);
|
|
const worker = workerOf(self);
|
|
const terminals = async (ctx: Ctx) => expectVariant(await ctx.get(AgentTerminals, {}), "worker");
|
|
/** One call of the server's object, as this worker, cancelled with `context`. */
|
|
const via = <T>(
|
|
call: (server: Awaited<ReturnType<typeof terminals>>, ctx: Ctx) => Promise<T>,
|
|
context: Context,
|
|
): Promise<T> => worker().root(async (ctx) => call(await terminals(ctx), ctx), context);
|
|
const backend: TerminalBackend = {
|
|
list: async (context) => (await via((server, ctx) => server.list({}, ctx), context)).windows,
|
|
open: (args, context) => via((server, ctx) => server.open(args, ctx), context),
|
|
send: (args, context) => via((server, ctx) => server.send(args, ctx), context),
|
|
cursor: (target, context) => via((server, ctx) => server.cursor({ target }, ctx), context),
|
|
read: (args, context) => via((server, ctx) => server.read(args, ctx), context),
|
|
capture: (args, context) => via((server, ctx) => server.capture(args, ctx), context),
|
|
close: (args, context) => via((server, ctx) => server.close(args, ctx), context),
|
|
};
|
|
const caller: TerminalCaller = async (api, context) => {
|
|
const here = await harness().environments.locate(api.conversationId, context, api);
|
|
const sandbox = await harness().environments.sandbox(here.env);
|
|
return sandbox === undefined ? { here } : { here, sandbox };
|
|
};
|
|
const offer = (reach: TerminalReach) => ({
|
|
[TERMINAL_EXTENSION]: createTerminalExtension(reach, backend, caller),
|
|
});
|
|
let offered: TerminalReach = "codemode";
|
|
const extension = self.writable<Readonly<Record<string, Extension>>>(offer(offered));
|
|
self.contribute(Extensions, extension);
|
|
// Code mode switched off or not loaded: scripts cannot reach the tool, so `tool_search` loads it.
|
|
self.on(self.registry(ExtensionSwitches), ({ value }) => {
|
|
const reach: TerminalReach = value.get(CODEMODE_EXTENSION) === true ? "codemode" : "tool_search";
|
|
if (reach === offered) return;
|
|
offered = reach;
|
|
extension.set(offer(reach));
|
|
});
|
|
});
|
|
});
|