zerogterm 0.8.0-alpha.1 → 0.9.1-alpha.1

package/dist/main/main/mcp-protocol.js

@@ -0,0 +1,51 @@
+export function isMcpCapability(value) {
+    return value === 'workspace:read' || value === 'workspace:restore' || value === 'workspace:write' ||
+        value === 'session:read' || value === 'session:create' || value === 'session:close' || value === 'session:execute';
+}
+export function requireMcpCapability(lease, capability, now = Date.now()) {
+    if (!lease)
+        throw new Error('No AI control lease is active.');
+    if (lease.expiresAt <= now)
+        throw new Error('The AI control lease has expired.');
+    if (!lease.capabilities.includes(capability))
+        throw new Error(`The AI connection lacks ${capability} capability.`);
+}
+export function requireBoundedString(value, field, max = 256) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new Error(`${field} is required.`);
+    const clean = value.trim();
+    if (clean.length > max)
+        throw new Error(`${field} is too long.`);
+    if (/[\u0000-\u001f\u007f]/.test(clean))
+        throw new Error(`${field} contains control characters.`);
+    return clean;
+}
+export function requireWorkspaceId(value) {
+    return requireBoundedString(value, 'workspaceId', 64);
+}
+export function requireSessionId(value) {
+    return requireBoundedString(value, 'sessionId', 128);
+}
+export function requireWorkspaceName(value) {
+    const name = requireBoundedString(value, 'name', 49);
+    if (!/^[A-Za-z0-9](?:[A-Za-z0-9_.]|-| ){0,48}$/.test(name)) {
+        throw new Error('Workspace name contains unsupported characters.');
+    }
+    return name;
+}
+export function requireStoredWorkspaceFile(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('A workspace file is required.');
+    const file = value;
+    if (file.version !== 1 || !Array.isArray(file.workspaces))
+        throw new Error('Invalid workspace file.');
+    return value;
+}
+export function boundedDeadline(value, defaultMs = 10_000, maxMs = 60_000) {
+    if (value === undefined)
+        return defaultMs;
+    if (!Number.isInteger(value) || value < 100 || value > maxMs) {
+        throw new Error(`deadlineMs must be between 100 and ${maxMs}.`);
+    }
+    return value;
+}

package/dist/main/main/mcp-server.js

@@ -0,0 +1,221 @@
+import { createServer } from 'node:http';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+import { McpControl } from './mcp-control.js';
+import { requireWorkspaceId } from './mcp-protocol.js';
+const MAX_BODY_BYTES = 128 * 1024;
+export const DEFAULT_MCP_PORT = 60056;
+const DEFAULT_CAPABILITIES = ['workspace:read', 'session:read'];
+const ALL_CAPABILITIES = [
+    'workspace:read', 'workspace:restore', 'workspace:write',
+    'session:read', 'session:create', 'session:close', 'session:execute'
+];
+/** Local authenticated MCP endpoint owned by the running ZeroG instance. */
+export class McpServerHost {
+    providers;
+    control;
+    version;
+    configuredPort;
+    token;
+    http;
+    constructor(options) {
+        this.providers = options.providers;
+        this.control = options.control ?? new McpControl();
+        this.version = options.version ?? '0.0.0';
+        this.configuredPort = options.port ?? DEFAULT_MCP_PORT;
+        this.token = options.token ?? process.env.MCP_BEARER_TOKEN ?? randomBytes(32).toString('base64url');
+    }
+    status() {
+        return this.control.status();
+    }
+    async start() {
+        if (this.http)
+            return { endpoint: this.endpoint(), token: this.token };
+        this.http = createServer((req, res) => { void this.handle(req, res); });
+        await new Promise((resolve, reject) => {
+            this.http.once('error', reject);
+            this.http.listen(this.configuredPort, '127.0.0.1', () => {
+                this.http.off('error', reject);
+                resolve();
+            });
+        });
+        const address = this.http.address();
+        const port = typeof address === 'object' && address ? address.port : this.configuredPort;
+        this.control.enable(`http://127.0.0.1:${port}/mcp`);
+        return { endpoint: this.endpoint(), token: this.token };
+    }
+    async stop() {
+        this.control.disable();
+        if (this.http) {
+            await new Promise((resolve) => this.http.close(() => resolve()));
+            this.http = undefined;
+        }
+    }
+    endpoint() {
+        const address = this.http?.address();
+        const port = typeof address === 'object' && address ? address.port : this.configuredPort;
+        return `http://127.0.0.1:${port}/mcp`;
+    }
+    async handle(req, res) {
+        if (req.url !== '/mcp')
+            return respond(res, 404, { error: 'Not found' });
+        if (!this.authorized(req))
+            return respond(res, 401, { error: 'Authorization required' }, { 'WWW-Authenticate': 'Bearer' });
+        if (req.method !== 'POST' && req.method !== 'GET' && req.method !== 'DELETE') {
+            return respond(res, 405, { error: 'Method not allowed' }, { Allow: 'GET, POST, DELETE' });
+        }
+        if (req.method === 'POST') {
+            const body = await readJson(req);
+            if (body.error)
+                return respond(res, body.status, { error: body.error });
+            // Stateless transport: each HTTP request gets an independent protocol
+            // wrapper, so one client cannot wedge the desktop-wide MCP endpoint.
+            const mcp = this.buildMcpServer();
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+            await mcp.connect(transport);
+            await transport.handleRequest(req, res, body.value);
+            return;
+        }
+        respond(res, 400, { error: 'This stateless endpoint accepts POST requests only.' });
+    }
+    authorized(req) {
+        const value = req.headers.authorization;
+        if (!value?.startsWith('Bearer '))
+            return false;
+        const received = Buffer.from(value.slice(7));
+        const expected = Buffer.from(this.token);
+        return received.length === expected.length && timingSafeEqual(received, expected);
+    }
+    buildMcpServer() {
+        const server = new McpServer({ name: 'zerogterm', version: this.version });
+        server.registerTool('zerog_get_connection_status', {
+            description: 'Return ZeroG MCP connection and AI lease state.',
+            inputSchema: z.object({})
+        }, async () => text(this.control.status()));
+        server.registerTool('zerog_list_workspaces', {
+            description: 'List saved ZeroG workspaces and pane metadata.',
+            inputSchema: z.object({ clientId: z.string().min(1) })
+        }, async ({ clientId }) => {
+            this.control.require(clientId, 'workspace:read');
+            return text(await this.providers.listWorkspaces());
+        });
+        server.registerTool('zerog_list_sessions', {
+            description: 'List ZeroG terminal sessions without terminal output or credentials.',
+            inputSchema: z.object({ clientId: z.string().min(1) })
+        }, async ({ clientId }) => {
+            this.control.require(clientId, 'session:read');
+            return text(await this.providers.listSessions());
+        });
+        server.registerTool('zerog_restore_workspace', {
+            description: 'Restore a saved workspace and recreate only missing sessions. SSH authentication remains user-controlled.',
+            inputSchema: z.object({ clientId: z.string().min(1), workspaceId: z.string().min(1).max(64) })
+        }, async ({ clientId, workspaceId }) => {
+            this.control.require(clientId, 'workspace:restore');
+            if (!this.providers.restoreWorkspace)
+                throw new Error('Workspace restoration is not available.');
+            return text(await this.providers.restoreWorkspace(requireWorkspaceId(workspaceId)));
+        });
+        server.registerTool('zerog_create_workspace', {
+            description: 'Create and select a new blank workspace using the next workspace-N name.',
+            inputSchema: z.object({ clientId: z.string().min(1) })
+        }, async ({ clientId }) => {
+            this.control.require(clientId, 'workspace:write');
+            if (!this.providers.createWorkspace)
+                throw new Error('Workspace creation is not available.');
+            return text(await this.providers.createWorkspace(''));
+        });
+        server.registerTool('zerog_create_project_workspace', {
+            description: 'Create or replace a workspace containing local project panes. Does not execute commands.',
+            inputSchema: z.object({
+                clientId: z.string().min(1),
+                name: z.string().min(1).max(49),
+                projects: z.array(z.object({ name: z.string().min(1).max(64), cwd: z.string().min(1).max(512), backend: z.string().max(32).optional() })).min(1).max(4)
+            })
+        }, async ({ clientId, name, projects }) => {
+            this.control.require(clientId, 'workspace:write');
+            this.control.require(clientId, 'session:create');
+            if (!this.providers.createProjectWorkspace)
+                throw new Error('Project workspace creation is not available.');
+            return text(await this.providers.createProjectWorkspace({ name, projects }));
+        });
+        server.registerTool('zerog_create_ssh_session', {
+            description: 'Open a new SSH session in the active ZeroG workspace. Authentication and host-key prompts remain user-controlled.',
+            inputSchema: z.object({
+                clientId: z.string().min(1),
+                target: z.string().min(1).max(512),
+                name: z.string().min(1).max(128).optional()
+            })
+        }, async ({ clientId, target, name }) => {
+            this.control.require(clientId, 'session:create');
+            if (!this.providers.createSshSession)
+                throw new Error('SSH session creation is not available.');
+            return text(await this.providers.createSshSession({ target, ...(name === undefined ? {} : { name }) }));
+        });
+        server.registerTool('zerog_request_command', {
+            description: 'Request a local command for explicit user approval. This never executes the command by itself.',
+            inputSchema: z.object({ clientId: z.string().min(1), sessionId: z.string().min(1).max(128), command: z.string().min(1).max(512), timeoutMs: z.number().int().min(100).max(30000).optional(), outputBytes: z.number().int().min(256).max(16384).optional() })
+        }, async ({ clientId, sessionId, command, timeoutMs, outputBytes }) => {
+            this.control.require(clientId, 'session:execute');
+            if (!this.providers.requestCommand)
+                throw new Error('Command requests are not available.');
+            return text(await this.providers.requestCommand({ clientId, sessionId, command, ...(timeoutMs === undefined ? {} : { timeoutMs }), ...(outputBytes === undefined ? {} : { outputBytes }) }));
+        });
+        server.registerTool('zerog_get_command_result', {
+            description: 'Read the state of a command request owned by this client.',
+            inputSchema: z.object({ clientId: z.string().min(1), requestId: z.string().min(1).max(128) })
+        }, async ({ clientId, requestId }) => {
+            this.control.require(clientId, 'session:execute');
+            if (!this.providers.getCommandResult)
+                throw new Error('Command requests are not available.');
+            return text(await this.providers.getCommandResult({ clientId, requestId }));
+        });
+        server.registerTool('zerog_cancel_command', {
+            description: 'Cancel a pending command request owned by this client.',
+            inputSchema: z.object({ clientId: z.string().min(1), requestId: z.string().min(1).max(128) })
+        }, async ({ clientId, requestId }) => {
+            this.control.require(clientId, 'session:execute');
+            if (!this.providers.cancelCommand)
+                throw new Error('Command requests are not available.');
+            return text(await this.providers.cancelCommand({ clientId, requestId }));
+        });
+        server.registerTool('zerog_acquire_control', {
+            description: 'Acquire the single AI control lease for this local ZeroG instance.',
+            inputSchema: z.object({ clientId: z.string().min(1).max(128), clientName: z.string().max(128).optional(), capabilities: z.array(z.enum(ALL_CAPABILITIES)).optional() })
+        }, async ({ clientId, clientName, capabilities }) => text(this.control.connect(clientId, clientName, (capabilities ?? DEFAULT_CAPABILITIES))));
+        server.registerTool('zerog_renew_control', {
+            description: 'Renew the current AI control lease.',
+            inputSchema: z.object({ clientId: z.string().min(1) })
+        }, async ({ clientId }) => text(this.control.renew(clientId)));
+        server.registerTool('zerog_upgrade_control', {
+            description: 'Add capabilities to the current AI control lease without taking control from another client.',
+            inputSchema: z.object({ clientId: z.string().min(1), capabilities: z.array(z.enum(ALL_CAPABILITIES)).min(1) })
+        }, async ({ clientId, capabilities }) => text(this.control.upgrade(clientId, capabilities)));
+        return server;
+    }
+}
+function text(value) {
+    return { content: [{ type: 'text', text: JSON.stringify(value) }] };
+}
+function respond(res, status, body, headers = {}) {
+    res.writeHead(status, { 'Content-Type': 'application/json', ...headers });
+    res.end(JSON.stringify(body));
+}
+async function readJson(req) {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of req) {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += data.length;
+        if (size > MAX_BODY_BYTES)
+            return { error: 'Request body is too large.', status: 413 };
+        chunks.push(data);
+    }
+    try {
+        return { value: JSON.parse(Buffer.concat(chunks).toString('utf8')), status: 200 };
+    }
+    catch {
+        return { error: 'Request body must be valid JSON.', status: 400 };
+    }
+}

package/dist/main/main/preload.cjs

@@ -21,6 +21,34 @@ const api = {
   },
   loadWorkspaces: () => ipcRenderer.invoke('workspaces:load'),
   saveWorkspaces: (file) => ipcRenderer.invoke('workspaces:save', file),
+  mcpStatus: () => ipcRenderer.invoke('mcp:status'),
+  revokeMcpControl: () => ipcRenderer.invoke('mcp:revoke'),
+  startMcp: () => ipcRenderer.invoke('mcp:start'),
+  stopMcp: () => ipcRenderer.invoke('mcp:stop'),
+  onMcpStatus: (callback) => {
+    const listener = (_event, payload) => callback(payload);
+    ipcRenderer.on('mcp:status', listener);
+    return () => ipcRenderer.removeListener('mcp:status', listener);
+  },
+  onMcpWorkspaceRestored: (callback) => {
+    const listener = (_event, payload) => callback(payload);
+    ipcRenderer.on('mcp:workspace-restored', listener);
+    return () => ipcRenderer.removeListener('mcp:workspace-restored', listener);
+  },
+  onMcpSshSessionCreated: (callback) => {
+    const listener = (_event, payload) => callback(payload);
+    ipcRenderer.on('mcp:ssh-session-created', listener);
+    return () => ipcRenderer.removeListener('mcp:ssh-session-created', listener);
+  },
+  listMcpExecutions: () => ipcRenderer.invoke('mcp:executions:list'),
+  approveMcpExecution: (requestId) => ipcRenderer.invoke('mcp:execution:approve', requestId),
+  rejectMcpExecution: (requestId) => ipcRenderer.invoke('mcp:execution:reject', requestId),
+  cancelMcpExecution: (requestId) => ipcRenderer.invoke('mcp:execution:cancel', requestId),
+  onMcpExecution: (callback) => {
+    const listener = (_event, payload) => callback(payload);
+    ipcRenderer.on('mcp:execution', listener);
+    return () => ipcRenderer.removeListener('mcp:execution', listener);
+  },
   listBackends: () => ipcRenderer.invoke('sessions:backends'),
   listWslDistributions: () => ipcRenderer.invoke('sessions:wslDistributions'),
   createLocalSession: (request) => ipcRenderer.invoke('sessions:createLocal', request),

package/dist/main/main/prompt-classifier.js

@@ -0,0 +1,14 @@
+const PASSWORD = /password|passwd|login\s*:/i;
+const PASSPHRASE = /passphrase|private\s+key/i;
+const CODE = /verification|one[- ]time|security\s+code|otp|authenticator/i;
+const HOST_KEY = /are you sure you want to continue connecting|authenticity of host|fingerprint|host key/i;
+const ANSI = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+/** Classify untrusted terminal text without ever accepting an answer. */
+export function classifyMcpPrompt(raw) {
+    const text = raw.replace(ANSI, '').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '').slice(0, 512);
+    const kind = PASSPHRASE.test(text) ? 'passphrase'
+        : CODE.test(text) ? 'verification-code'
+            : HOST_KEY.test(text) ? 'host-key'
+                : PASSWORD.test(text) ? 'password' : 'unknown';
+    return { kind, text, answerableByMcp: false };
+}

package/dist/main/main/workspace-store.js

@@ -96,6 +96,7 @@ function normalizeMember(value) {
     const screenName = optionalText(item.screenName, 64);
     const sshTarget = optionalText(item.sshTarget);
     const backend = optionalText(item.backend, 32);
+    const cwd = optionalText(item.cwd, 512);
     if (host)
         member.host = host;
     if (screenName)
@@ -104,6 +105,8 @@ function normalizeMember(value) {
         member.sshTarget = sshTarget;
     if (backend)
         member.backend = backend;
+    if (cwd)
+        member.cwd = cwd;
     return member;
 }
 function normalizeView(value, memberIds) {