@openagents-org/agent-launcher 0.2.193 → 0.2.195

package/src/mcp-server.js

@@ -22,6 +22,8 @@ const _activeTunnels = {};
 
 // ── Tool definitions ────────────────────────────────────────────────────────
 
+const v11 = require('./tools-v11');
+
 function buildToolDefs(disabledModules) {
   const tools = [
     // -- Workspace core (always enabled) --
@@ -73,6 +75,21 @@ function buildToolDefs(disabledModules) {
           required: ['file_id'],
         },
       },
+      {
+        name: 'workspace_publish_project',
+        description: 'Publish a static web project as one previewable artifact. Include its HTML, images, CSS, JavaScript and data using relative paths. No servers or dependencies are installed. Exclude secrets and hidden files. Reuse project_id and expected_revision to update while keeping its link and pins.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string' }, entrypoint: { type: 'string', description: 'Relative HTML entry page, usually index.html' },
+            project_id: { type: 'string' }, expected_revision: { type: 'string', description: 'Revision returned by the last publish or preview' },
+            files: { type: 'array', maxItems: 500, items: { type: 'object', properties: {
+              path: { type: 'string' }, content: { type: 'string', description: 'UTF-8 text, or use content_base64 for binary files' },
+              content_base64: { type: 'string' },
+            }, required: ['path'] } },
+          }, required: ['title', 'files'],
+        },
+      },
       {
         name: 'workspace_write_file',
         description: 'Write/upload a file to shared workspace storage.',
@@ -442,6 +459,40 @@ function buildToolDefs(disabledModules) {
     );
   }
 
+  // -- Approvals (always on: a governance primitive, not a skill) --
+  tools.push(
+    {
+      name: 'workspace_request_approval',
+      description: 'Ask a human for permission BEFORE doing something consequential: deploying to production, spending money or calling paid APIs, sending email/messages to customers or external parties, deleting data, or any irreversible action you are unsure about. Workspace policy decides: the request may be auto-approved, auto-blocked, or paused until a person with the right role approves it in the thread. This call blocks (up to wait_seconds) until a decision arrives and returns it. If it returns "pending", stop and wait — the decision will arrive as a message in this thread.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', description: 'Short label of what you want to do, e.g. "Deploy 2.4 hotfix to prod-eu" or "Email 38 affected customers"' },
+          kind: {
+            type: 'string',
+            enum: ['deploy', 'spend', 'external_send', 'repo_read', 'repo_write', 'data_delete', 'shell', 'other'],
+            description: 'Category the policy is keyed on. deploy=production deploys; spend=money/paid APIs; external_send=email/messages leaving the workspace; repo_read/repo_write=git; data_delete=destructive data ops; shell=commands with side effects; other=anything else',
+          },
+          details: { type: 'string', description: 'The exact command, diff summary, recipient list, URL or amount — what a reviewer needs to decide' },
+          risk: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Your own risk estimate' },
+          wait_seconds: { type: 'integer', description: 'How long to wait for a decision before returning "pending" (default 300, max 900)' },
+        },
+        required: ['action', 'kind'],
+      },
+    },
+    {
+      name: 'workspace_check_approval',
+      description: 'Check the status of an approval request you made earlier (by id). Use after workspace_request_approval returned "pending".',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          approval_id: { type: 'string', description: 'The approval id returned by workspace_request_approval' },
+        },
+        required: ['approval_id'],
+      },
+    },
+  );
+
   // -- Knowledge Base --
   if (!disabledModules.has('knowledge')) {
     tools.push(
@@ -489,9 +540,37 @@ function buildToolDefs(disabledModules) {
     );
   }
 
+  // -- v1.1 milestone tools (always on) --
+  tools.push(...v11.toolDefs());
+
   return tools;
 }
 
+// ── Approvals ───────────────────────────────────────────────────────────────
+
+/**
+ * What the agent reads back from an approval. The verdict comes first so a
+ * model skimming the tool result cannot miss it.
+ */
+function formatApproval(a) {
+  const who = a.resolved_by === 'policy'
+    ? 'workspace policy'
+    : a.resolved_by ? `${a.resolved_by}${a.resolved_by_role ? ` (${a.resolved_by_role})` : ''}` : null;
+  const note = a.note ? `\nNote from approver: ${a.note}` : '';
+  switch (a.status) {
+    case 'approved':
+      return `APPROVED — "${a.action}" was approved by ${who}. You may proceed.${note}\n(approval id: ${a.id})`;
+    case 'rejected':
+      return `REJECTED — "${a.action}" was rejected by ${who}. Do NOT do it. Explain in the thread what you would have done and ask how to proceed.${note}\n(approval id: ${a.id})`;
+    case 'expired':
+      return `EXPIRED — nobody decided on "${a.action}" in time. Do not proceed; ask in the thread.\n(approval id: ${a.id})`;
+    default: {
+      const role = a.required_role === 'admin' ? 'an Admin' : a.required_role === 'owner' ? 'the Owner' : 'a workspace member';
+      return `PENDING — "${a.action}" is waiting for ${role} to approve. Do NOT proceed with this action. Stop here and end your turn; the decision will arrive as a new message in this thread (@mentioning you), or call workspace_check_approval with id ${a.id} later.`;
+    }
+  }
+}
+
 // ── MIME type detection ─────────────────────────────────────────────────────
 
 const MIME_MAP = {
@@ -521,12 +600,13 @@ function isTextMime(mime) {
 // ── MCP Server ──────────────────────────────────────────────────────────────
 
 class McpServer {
-  constructor({ wsClient, workspaceId, channelName, agentName, token, disabledModules }) {
+  constructor({ wsClient, workspaceId, channelName, agentName, token, disabledModules, requesterEmail = process.env.OPENAGENTS_REQUESTER_EMAIL || null }) {
     this.ws = wsClient;
     this.workspaceId = workspaceId;
     this.channelName = channelName;
     this.agentName = agentName;
     this.token = token;
+    this.requesterEmail = requesterEmail;
     this.disabledModules = disabledModules || new Set();
     this.tools = buildToolDefs(this.disabledModules);
   }
@@ -662,6 +742,20 @@ class McpServer {
         return text(str);
       }
 
+      case 'workspace_publish_project': {
+        const channel = this.channelName && !this.channelName.startsWith('dm:') ? this.channelName : undefined;
+        const files = args.files.map(file => {
+          if (typeof file.content_base64 !== 'string' && typeof file.content !== 'string') throw new Error('Each file needs content or content_base64');
+          return { path:file.path, content_base64:file.content_base64 ?? Buffer.from(file.content,'utf8').toString('base64') };
+        });
+        const result = await this.ws.publishWebProject(this.workspaceId, this.token, {
+          title:args.title, entrypoint:args.entrypoint || 'index.html', files,
+          channel_name:channel, visibility:channel ? 'inherit' : 'private',
+          source:`openagents:${this.agentName}`, expected_revision:args.expected_revision,
+        }, args.project_id);
+        return text(`Project published (id: ${result.id}, revision: ${result.revision}). Link it in your reply: [${args.title}](/v1/files/${encodeURIComponent(result.id)})`);
+      }
+
       case 'workspace_write_file': {
         const mime = args.content_type || detectMime(args.filename);
         let b64;
@@ -674,9 +768,10 @@ class McpServer {
           contentType: mime,
           source: `openagents:${this.agentName}`,
           channelName: this.channelName,
+          visibility: this.channelName ? 'inherit' : undefined,
         });
         const fileId = result.id || result.file_id || 'unknown';
-        return text(`File written: ${args.filename} (id: ${fileId})`);
+        return text(`File written: ${args.filename} (id: ${fileId}). Link it in your reply: [${args.filename}](/v1/files/${encodeURIComponent(fileId)})`);
       }
 
       case 'workspace_delete_file': {
@@ -745,6 +840,7 @@ class McpServer {
         const opts = {
           url: args.url || 'about:blank',
           source: `openagents:${this.agentName}`,
+          channel: this.channelName,
         };
         // Resolve context_name to context_id
         if (args.context_name) {
@@ -767,29 +863,29 @@ class McpServer {
       }
 
       case 'workspace_browser_navigate': {
-        const result = await this.ws.browserNavigate(this.workspaceId, this.token, args.tab_id, args.url);
+        const result = await this.ws.browserNavigate(this.workspaceId, this.token, args.tab_id, args.url, { source: `openagents:${this.agentName}`, channel: this.channelName });
         const title = result.title || '';
         return text(`Navigated to: ${args.url}${title ? ` (title: ${title})` : ''}`);
       }
 
       case 'workspace_browser_click': {
-        const result = await this.ws.browserClick(this.workspaceId, this.token, args.tab_id, args.selector);
+        const result = await this.ws.browserClick(this.workspaceId, this.token, args.tab_id, args.selector, { source: `openagents:${this.agentName}`, channel: this.channelName });
         return text(`Clicked: ${args.selector}${result.url ? ` (url now: ${result.url})` : ''}`);
       }
 
       case 'workspace_browser_type': {
-        await this.ws.browserType(this.workspaceId, this.token, args.tab_id, args.selector, args.text);
+        await this.ws.browserType(this.workspaceId, this.token, args.tab_id, args.selector, args.text, { source: `openagents:${this.agentName}`, channel: this.channelName });
         return text(`Typed into ${args.selector}: ${args.text.slice(0, 50)}${args.text.length > 50 ? '...' : ''}`);
       }
 
       case 'workspace_browser_screenshot': {
-        const buf = await this.ws.browserScreenshot(this.workspaceId, this.token, args.tab_id);
+        const buf = await this.ws.browserScreenshot(this.workspaceId, this.token, args.tab_id, { source: `openagents:${this.agentName}`, channel: this.channelName });
         const b64 = Buffer.isBuffer(buf) ? buf.toString('base64') : buf;
         return image(b64, 'image/png');
       }
 
       case 'workspace_browser_snapshot': {
-        const snapshot = await this.ws.browserSnapshot(this.workspaceId, this.token, args.tab_id);
+        const snapshot = await this.ws.browserSnapshot(this.workspaceId, this.token, args.tab_id, { source: `openagents:${this.agentName}`, channel: this.channelName });
         return text(typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot));
       }
 
@@ -1039,6 +1135,35 @@ class McpServer {
         return text(lines.join('\n'));
       }
 
+      // ── Approvals ──
+
+      case 'workspace_request_approval': {
+        const waitSec = Math.max(0, Math.min(900, Number(args.wait_seconds) || 300));
+        let approval = await this.ws.createApproval(this.workspaceId, this.token, {
+          channel: this.channelName,
+          kind: args.kind || 'other',
+          action: args.action,
+          details: args.details,
+          risk: args.risk,
+          source: `openagents:${this.agentName}`,
+        });
+        const deadline = Date.now() + waitSec * 1000;
+        while (approval.status === 'pending' && Date.now() < deadline) {
+          await new Promise((r) => setTimeout(r, 3000));
+          try {
+            approval = await this.ws.getApproval(this.workspaceId, this.token, approval.id);
+          } catch (e) {
+            this._log(`approval poll failed: ${e.message}`);
+          }
+        }
+        return text(formatApproval(approval));
+      }
+
+      case 'workspace_check_approval': {
+        const approval = await this.ws.getApproval(this.workspaceId, this.token, args.approval_id);
+        return text(formatApproval(approval));
+      }
+
       // ── Knowledge Base ──
 
       case 'workspace_list_knowledge': {
@@ -1087,8 +1212,11 @@ class McpServer {
         return text(`Knowledge entry deleted: ${args.entry_id}`);
       }
 
-      default:
+      default: {
+        const handled = await v11.dispatch(this, name, args, { text, image });
+        if (handled !== undefined) return handled;
         throw new Error(`Unknown tool: ${name}`);
+      }
     }
   }
 
@@ -1114,7 +1242,8 @@ function jsonRpcError(id, code, message) {
 // ── Entry point (called from cli.js) ────────────────────────────────────────
 
 function runMcpServer(opts) {
-  const wsClient = new WorkspaceClient(opts.endpoint);
+  // Every tool call (incl. tools-v11 via server.ws) is made for opts.agentName.
+  const wsClient = new WorkspaceClient(opts.endpoint, { agentName: opts.agentName });
   const server = new McpServer({
     wsClient,
     workspaceId: opts.workspaceId,

package/src/node-config.js

@@ -98,7 +98,7 @@ function recordPairing(nodeKey, pairing) {
   const stamped = { ...pairing, paired_at: new Date().toISOString() };
   const pairings = [
     stamped,
-    ...pairingsOf(readNode()).filter((p) => p.workspace_id !== pairing.workspace_id),
+    ...pairingsOf(readNode()).filter((p) => pairing.node_id && p.node_id ? p.node_id !== pairing.node_id : p.workspace_id !== pairing.workspace_id),
   ];
   saveNode({ node_key: nodeKey, ...stamped, pairings });
 }
@@ -116,17 +116,19 @@ function recordPairing(nodeKey, pairing) {
  * @param workspaceId which pairing to drop; defaults to the top-level one.
  * @returns the pairing that was dropped, or null if there was no such pairing.
  */
-function clearPairing(workspaceId) {
+function clearPairing(workspaceId, nodeId) {
   const record = readNode();
   if (!record) return null;
   const target = workspaceId || record.workspace_id;
   if (!target) return null;
 
   const pairings = pairingsOf(record);
-  const dropped = pairings.find((p) => p.workspace_id === target);
+  const candidates = pairings.filter((p) => p.workspace_id === target);
+  if (!nodeId && candidates.length > 1) throw new Error("Choose a specific device connection");
+  const dropped = candidates.find((p) => !nodeId || p.node_id === nodeId);
   if (!dropped) return null;
 
-  const remaining = pairings.filter((p) => p.workspace_id !== target);
+  const remaining = pairings.filter((p) => p !== dropped);
   saveNode({ node_key: record.node_key, ...remaining[0], pairings: remaining });
   return {
     node_id: dropped.node_id,

package/src/postinstall-stub.js

@@ -0,0 +1,69 @@
+'use strict';
+
+/**
+ * The placeholder an npm package ships where its native binary goes.
+ *
+ * opencode-ai and @anthropic-ai/claude-code are both published this way: the
+ * package's `bin` (bin/opencode.exe, bin/claude.exe) is a few hundred bytes of
+ * shell that prints "postinstall … not run" and exits 1, and the package's
+ * postinstall script swaps in the real binary from a per-platform optional
+ * dependency. Skip that script — `ignore-scripts=true` in an npmrc,
+ * `--ignore-scripts`, pnpm and bun by default — and the install still exits 0
+ * with the placeholder sitting where the CLI should be. It resolves on PATH
+ * and it has the right name, so nothing about it looks like a missing install:
+ * the launcher reports the agent installed, and every run fails on whatever
+ * check happens to come next.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// A native CLI is tens of megabytes; the placeholders are about 500 bytes.
+const STUB_MAX_BYTES = 4096;
+const STUB_SIGNATURE = /postinstall (script )?(was|did) not run|native binary not installed/i;
+
+/** Whether text a CLI printed is its package's placeholder talking. */
+function isPostinstallStubOutput(text) {
+  return STUB_SIGNATURE.test(String(text || ''));
+}
+
+function isStubFile(file) {
+  try {
+    const st = fs.statSync(file);
+    if (!st.isFile() || st.size > STUB_MAX_BYTES) return false;
+    return STUB_SIGNATURE.test(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The files an npm `.cmd` shim launches. The shim is a wrapper npm wrote
+ * beside the package, never the placeholder itself — the placeholder is what
+ * it points at (`"%dp0%\node_modules\opencode-ai\bin\opencode.exe" %*`).
+ */
+function cmdShimTargets(file) {
+  if (!/\.cmd$/i.test(file)) return [];
+  try {
+    if (fs.statSync(file).size > STUB_MAX_BYTES) return [];
+    const dir = path.dirname(file);
+    const text = fs.readFileSync(file, 'utf-8');
+    return [...text.matchAll(/"%(?:~dp0|dp0%)\\?([^"\r\n]+)"/g)]
+      .map((m) => path.join(dir, ...m[1].split(/[\\/]+/)));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Whether `file` is such a placeholder — directly, through the symlink npm
+ * puts in `.bin`, or through a Windows `.cmd` shim. Read off disk rather than
+ * by running it: on Windows the placeholder is shell text named `.exe`, and
+ * starting it raises a "this app can't run on your PC" dialog.
+ */
+function isPostinstallStub(file) {
+  if (!file) return false;
+  return [file, ...cmdShimTargets(file)].some(isStubFile);
+}
+
+module.exports = { isPostinstallStub, isPostinstallStubOutput };

package/src/tools-v11/brief.js

@@ -0,0 +1,97 @@
+'use strict';
+/**
+ * v1.1 M5 — the shared work brief.
+ *
+ * Every thread has one brief (objective, owner, latest result, open
+ * questions, next step) that people read instead of scrolling the
+ * transcript. Agents keep it current after each meaningful step.
+ *
+ *   workspace_get_brief    { channel? }
+ *   workspace_update_brief { objective?, latest_result?, open_questions?, next_step?, owner? }
+ *
+ * Only the fields passed to update are changed; the backend records the
+ * writer as `openagents:<agent>`.
+ */
+
+const defs = [
+  {
+    name: 'workspace_get_brief',
+    description:
+      'Read the shared work brief of a thread: objective, owner of the next step, latest result, ' +
+      'open questions and next step, plus who directs the thread (director_email). Defaults to the current thread.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        channel: { type: 'string', description: 'Thread id (default: the current thread)' },
+      },
+    },
+  },
+  {
+    name: 'workspace_update_brief',
+    description:
+      'Update the current thread\'s shared work brief. Pass only the fields that changed. ' +
+      'Call it after each meaningful step so people can see where the work stands without reading the transcript.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        objective: { type: 'string', description: 'What this thread is trying to achieve (one or two sentences)' },
+        latest_result: { type: 'string', description: 'The most recent concrete outcome (what was produced / verified)' },
+        open_questions: { type: 'array', items: { type: 'string' }, description: 'Questions blocking or shaping the work. Replaces the list.' },
+        next_step: { type: 'string', description: 'The very next action' },
+        owner: { type: 'string', description: 'Who owns the next step: "openagents:<agent>" or "human:<email>"' },
+      },
+    },
+  },
+];
+
+const FIELDS = ['objective', 'latest_result', 'open_questions', 'next_step', 'owner'];
+
+function renderBrief(b) {
+  if (!b) return 'No brief yet.';
+  const lines = [`Brief for ${b.channel || 'this thread'}:`];
+  if (b.director_email) lines.push(`Directed by: ${b.director_email}`);
+  lines.push(`Objective: ${b.objective || '—'}`);
+  lines.push(`Owner of next step: ${b.owner || '—'}`);
+  lines.push(`Latest result: ${b.latest_result || '—'}`);
+  const qs = Array.isArray(b.open_questions) ? b.open_questions : [];
+  lines.push(qs.length ? `Open questions:\n${qs.map((q) => `  - ${q}`).join('\n')}` : 'Open questions: —');
+  lines.push(`Next step: ${b.next_step || '—'}`);
+  if (b.updated_by) lines.push(`Updated by ${b.updated_by}${b.updated_at ? ` at ${b.updated_at}` : ''}`);
+  return lines.join('\n');
+}
+
+async function handle(server, name, args, helpers) {
+  const { text } = helpers;
+  args = args || {};
+
+  if (name === 'workspace_get_brief') {
+    const channel = (args.channel && String(args.channel).trim()) || server.channelName;
+    if (!channel) return text('No thread in scope — pass `channel`.');
+    const brief = await server.ws.getBrief(server.workspaceId, server.token, channel);
+    return text(renderBrief(brief));
+  }
+
+  if (name === 'workspace_update_brief') {
+    if (!server.channelName) return text('No thread in scope — the brief belongs to a thread.');
+    const fields = {};
+    for (const k of FIELDS) {
+      if (args[k] === undefined) continue;
+      if (k === 'open_questions') {
+        fields[k] = Array.isArray(args[k]) ? args[k].map((q) => String(q)) : [];
+      } else {
+        fields[k] = args[k] === null ? null : String(args[k]);
+      }
+    }
+    if (Object.keys(fields).length === 0) {
+      return text('Nothing to update — pass at least one of: ' + FIELDS.join(', ') + '.');
+    }
+    const brief = await server.ws.putBrief(server.workspaceId, server.token, server.channelName, fields, {
+      source: `openagents:${server.agentName}`,
+    });
+    return text(`Brief updated (${Object.keys(fields).join(', ')}).\n${renderBrief(brief)}`);
+  }
+
+  return undefined;
+}
+
+module.exports = { defs, handle };

package/src/tools-v11/index.js

@@ -0,0 +1,28 @@
+'use strict';
+/**
+ * Roadmap v1.1 workspace tools — one module per milestone so parallel work
+ * never edits the same file. Each module exports:
+ *   defs   : MCP tool definitions (array)
+ *   handle : async (server, name, args, helpers) => result | undefined
+ * `server` is the McpServer instance (ws, workspaceId, channelName,
+ * agentName, token, _log); `helpers` is { text, image }.
+ */
+const modules = [
+  require('./presence-handoff'),  // M3/M6 — presence detail + structured hand-off
+  require('./brief'),             // M5 — shared work brief
+];
+
+function toolDefs() {
+  return modules.flatMap((m) => m.defs || []);
+}
+
+async function dispatch(server, name, args, helpers) {
+  for (const m of modules) {
+    if (!m.handle) continue;
+    const r = await m.handle(server, name, args, helpers);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+
+module.exports = { toolDefs, dispatch };