@ours.network/claude-code 1.1.1 → 1.2.0-nightly.1

package/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "ours.network",
   "displayName": "ours.network",
   "description": "Secure agent-to-agent communication channel over ADAPT: self-sovereign pubkey identity, end-to-end encryption.",
-  "version": "1.1.1",
+  "version": "1.2.0-nightly.1",
   "author": {
     "name": "Adapt Toolkit"
   },

package/README.md

@@ -0,0 +1,16 @@
+# OURS Claude Code plugin
+
+The plugin connects Claude's existing native session to the selected OURS server.
+Its host bridge and hooks remain part of the Claude integration; the main MCP
+server runs with the server installation.
+
+New plugin invocations select explicit `OURS_CONFIG` first, otherwise the private
+`~/.ours-client/profile.json` when present. With the managed profile, ordinary
+`claude` launches need no environment override. The file contains the existing
+`endpoint`, `expectedInstanceId` and absolute `credentialPath` tuple. Invalid or
+unreadable managed profiles fail without selecting Docker or a local MCP server.
+When neither selection exists, existing unmanaged behavior remains available.
+
+An explicit override applies to a new invocation. It does not rebind existing
+sessions or change `OURS_MCP_CONFIG`, application state or native ownership.
+The existing SessionEnd hook remains responsible for native session completion.

package/bin/container-file-transfer.mjs

@@ -0,0 +1,147 @@
+import { randomUUID } from 'node:crypto';
+import { createReadStream, createWriteStream, mkdirSync } from 'node:fs';
+import { basename, dirname, resolve } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { pipeline } from 'node:stream/promises';
+
+function helperInvocation(container, command, args) {
+  const entrypoint = container.args.indexOf('/opt/ours/node_modules/@ours.network/mcp/dist/container.js');
+  return { ...container, args: [...container.args.slice(0, entrypoint + 2), command, ...args] };
+}
+
+function helperJson(container, command, args) {
+  const call = helperInvocation(container, command, args);
+  const child = spawnSync(call.command, call.args, { env: call.env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000, maxBuffer: 1024 * 1024 });
+  if (child.error) throw child.error;
+  if (child.status !== 0) throw new Error(child.stderr.trim() || `${command} exited ${child.status}`);
+  return JSON.parse(child.stdout);
+}
+
+async function runHelper(container, command, args, input, output) {
+  const call = helperInvocation(container, command, args);
+  const child = spawn(call.command, call.args, { env: call.env, stdio: ['pipe', 'pipe', 'pipe'] });
+  let stderr = '';
+  child.stderr.setEncoding('utf8');
+  child.stderr.on('data', (chunk) => { stderr += chunk; });
+  const exited = new Promise((resolveExit, reject) => {
+    child.once('error', reject);
+    child.once('close', (code, signal) => code === 0 ? resolveExit() : reject(new Error(stderr.trim() || `${command} exited ${signal ?? code}`)));
+  });
+  const streams = [];
+  if (input) streams.push(pipeline(input, child.stdin)); else child.stdin.end();
+  if (output) streams.push(pipeline(child.stdout, output)); else child.stdout.resume();
+  const results = await Promise.allSettled([...streams, exited]);
+  const failed = results.find((result) => result.status === 'rejected');
+  if (failed) throw failed.reason;
+}
+
+async function stageFile(container, id, hostPath) {
+  const abs = resolve(hostPath);
+  const call = helperInvocation(container, 'file-stage', [id, basename(abs)]);
+  const child = spawn(call.command, call.args, { env: call.env, stdio: ['pipe', 'pipe', 'pipe'] });
+  let stdout = '', stderr = '';
+  child.stdout.setEncoding('utf8'); child.stdout.on('data', (v) => { stdout += v; });
+  child.stderr.setEncoding('utf8'); child.stderr.on('data', (v) => { stderr += v; });
+  const exited = new Promise((resolveExit, reject) => {
+    child.once('error', reject);
+    child.once('close', (code, signal) => code === 0 ? resolveExit() : reject(new Error(stderr.trim() || `file-stage exited ${signal ?? code}`)));
+  });
+  const results = await Promise.allSettled([pipeline(createReadStream(abs), child.stdin), exited]);
+  const failed = results.find((result) => result.status === 'rejected');
+  if (failed) throw failed.reason;
+  return { path: JSON.parse(stdout).path, abs };
+}
+
+function toolError(id, error) {
+  return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `host file transfer failed: ${error instanceof Error ? error.message : String(error)}` }], isError: true } };
+}
+
+async function removeTransfer(container, id) {
+  try { await runHelper(container, 'file-remove', [id]); } catch { /* preserve the primary result */ }
+}
+
+async function eachLine(stream, visit) {
+  let pending = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    pending = Buffer.concat([pending, chunk]);
+    let newline;
+    while ((newline = pending.indexOf(10)) !== -1) {
+      const line = pending.subarray(0, newline + 1);
+      pending = pending.subarray(newline + 1);
+      await visit(line);
+    }
+  }
+  if (pending.length) await visit(pending);
+}
+
+export function runContainerProxy(container) {
+  const child = spawn(container.command, container.args, { stdio: ['pipe', 'pipe', 'inherit'], env: container.env });
+  const pending = new Map();
+  let stopping = false;
+  const stopInput = () => { stopping = true; process.stdin.destroy(); };
+  child.stdin.on('error', stopInput);
+  let outputWrites = Promise.resolve();
+  const writeOutput = (bytes) => { outputWrites = outputWrites.then(() => new Promise((done) => process.stdout.write(bytes, done))); return outputWrites; };
+
+  const inputDone = eachLine(process.stdin, async (raw) => {
+    let message;
+    try { message = JSON.parse(raw.toString('utf8')); } catch { child.stdin.write(raw); return; }
+    // Forward cancellation unchanged. The upstream handler owns cancellation;
+    // keep transfer tracking until its actual response so a completed save is
+    // copied to the host and its staging directory is removed.
+    if (message?.method === 'notifications/cancelled') { child.stdin.write(raw); return; }
+    if (message?.method !== 'tools/call' || !message.params?.arguments) { child.stdin.write(raw); return; }
+    const name = message.params.name;
+    if (name !== 'send_file' && name !== 'save_file') { child.stdin.write(raw); return; }
+    const args = message.params.arguments;
+    if (name === 'send_file' && !args.path) { child.stdin.write(raw); return; }
+    const id = randomUUID();
+    try {
+      if (name === 'send_file') {
+        const staged = await stageFile(container, id, args.path);
+        message.params.arguments = { ...args, path: staged.path, filename: args.filename ?? basename(staged.abs) };
+        pending.set(message.id, { id, kind: name });
+      } else {
+        const hostPath = resolve(args.dest_path);
+        const target = helperJson(container, 'file-target', [id]);
+        message.params.arguments = { ...args, dest_path: target.path };
+        pending.set(message.id, { id, kind: name, hostPath, containerPath: target.path });
+      }
+      if (!stopping) child.stdin.write(`${JSON.stringify(message)}\n`);
+    } catch (error) {
+      await removeTransfer(container, id);
+      await writeOutput(`${JSON.stringify(toolError(message.id, error))}\n`);
+    }
+  }).catch((error) => {
+    if (!stopping) { process.stderr.write(`ours: container MCP input failed: ${error.message}\n`); process.exitCode = 1; child.kill(); }
+  }).finally(() => { if (!child.stdin.destroyed) child.stdin.end(); });
+
+  const outputDone = eachLine(child.stdout, async (raw) => {
+    let message;
+    try { message = JSON.parse(raw.toString('utf8')); } catch { await writeOutput(raw); return; }
+    const transfer = pending.get(message?.id);
+    if (!transfer) { await writeOutput(raw); return; }
+    pending.delete(message.id);
+    try {
+      if (transfer.kind === 'save_file' && !message.error && message.result?.isError !== true) {
+        mkdirSync(dirname(transfer.hostPath), { recursive: true });
+        await runHelper(container, 'file-read', [transfer.id], null, createWriteStream(transfer.hostPath));
+        for (const item of message.result?.content ?? []) {
+          if (item?.type === 'text' && typeof item.text === 'string') item.text = item.text.split(transfer.containerPath).join(transfer.hostPath);
+        }
+      }
+      await writeOutput(`${JSON.stringify(message)}\n`);
+    } catch (error) {
+      await writeOutput(`${JSON.stringify(toolError(message.id, error))}\n`);
+    } finally { await removeTransfer(container, transfer.id); }
+  });
+
+  child.on('error', (error) => { stopInput(); process.stderr.write(`ours: cannot launch container MCP: ${error.message}\n`); process.exitCode = 1; });
+  child.on('close', async (code, signal) => {
+    stopInput();
+    await Promise.allSettled([inputDone, outputDone, outputWrites]);
+    await Promise.allSettled([...pending.values()].map((v) => removeTransfer(container, v.id)));
+    if (signal) process.kill(process.pid, signal); else process.exitCode = process.exitCode || (code === null || code < 0 ? 1 : code);
+  });
+  return child;
+}

package/bin/container-launch.d.mts

@@ -0,0 +1,2 @@
+export function containerInvocation(command: string, args?: string[], env?: NodeJS.ProcessEnv): { command: string; args: string[]; env: NodeJS.ProcessEnv } | null;
+export function readContainerJson(command: string, env?: NodeJS.ProcessEnv): unknown;

package/bin/container-launch.mjs

@@ -0,0 +1,40 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+// An explicit container selection is authoritative: failures never fall back
+// to a host MCP or host application-identity configuration.
+export function containerInvocation(command, args = [], env = process.env) {
+  const explicitPath = (env.OURS_CONFIG ?? '').trim();
+  const path = explicitPath || join(homedir(), '.ours', 'config.json');
+  let profile;
+  try { profile = JSON.parse(readFileSync(path, 'utf8')); }
+  catch (error) {
+    if (!explicitPath && error.code === 'ENOENT') return null;
+    throw new Error(`cannot read OURS_CONFIG profile ${path}: ${error.message}`);
+  }
+  if (!profile || !Object.hasOwn(profile, 'composeFile')) return null;
+  if (typeof profile.composeFile !== 'string' || !isAbsolute(profile.composeFile)) throw new Error('composeFile must be an absolute path');
+  if (typeof profile.expectedInstanceId !== 'string' || !profile.expectedInstanceId.trim()) throw new Error('container profile requires expectedInstanceId');
+  if (profile.composeProject !== undefined && (typeof profile.composeProject !== 'string' || !profile.composeProject.trim())) throw new Error('composeProject must be a nonempty string');
+  const dockerArgs = ['compose', '-f', profile.composeFile];
+  if (profile.composeProject !== undefined) dockerArgs.push('-p', profile.composeProject);
+  dockerArgs.push('exec', '-T');
+  for (const name of ['CLAUDE_CODE_SESSION_ID', 'OURS_BIND_IDENTITY']) {
+    if (env[name] !== undefined) dockerArgs.push('-e', `${name}=${env[name]}`);
+  }
+  dockerArgs.push('daemon', 'node', '/opt/ours/node_modules/@ours.network/mcp/dist/container.js', profile.expectedInstanceId, command, ...args);
+  return { command: 'docker', args: dockerArgs, env: { ...env, OURS_DAEMON_ID: profile.expectedInstanceId } };
+}
+
+export function readContainerJson(command, env = process.env) {
+  const invocation = containerInvocation(command, [], env);
+  if (!invocation) return null;
+  const child = spawnSync(invocation.command, invocation.args, { env: invocation.env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000, maxBuffer: 1024 * 1024 });
+  if (child.error) throw child.error;
+  if (child.status !== 0) throw new Error(`ours container ${command} failed: ${child.stderr.trim() || child.status}`);
+  const value = JSON.parse(child.stdout);
+  if (value === null) throw new Error(`ours container ${command} returned null`);
+  return value;
+}

package/bin/proxy.mjs

@@ -1,90 +1,97 @@
 #!/usr/bin/env node
-// Resolves @ours.network/mcp (the MCP server dependency) and runs its
-// daemon CLI in proxy mode, forwarding the stdio MCP channel unchanged.
-//
-// Claude Code installs a plugin's npm dependency in one of two layouts,
-// depending on its version. Either inside this plugin's own per-version
-// node_modules (reachable by Node's default walk-up from this file), or in a
-// SHARED `~/.claude/plugins/npm-cache/node_modules` tree that sits as a SIBLING
-// of the plugin cache root — which a plain walk-up can never reach. We try the
-// default resolution first, then fall back to candidate node_modules roots (any
-// `npm-cache` found by walking up from this file, plus the documented
-// CLAUDE_PLUGIN_DATA dir) so the proxy launches under either layout.
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+import { containerInvocation } from './container-launch.mjs';
+import { runContainerProxy } from './container-file-transfer.mjs';
 
+const sessionEnd = process.argv[2] === 'session-end';
+const watch = process.argv[2] === 'watch';
+const command = sessionEnd ? 'session-end' : 'proxy';
+const forwarded = process.argv.slice(sessionEnd ? 3 : 2);
+const env = { ...process.env };
 const require = createRequire(import.meta.url);
-const SPEC = '@ours.network/mcp/dist/cli.js';
 const here = dirname(fileURLToPath(import.meta.url));
 
-// Base directories whose `node_modules` may hold the dependency when the
-// default walk-up cannot reach it. Each is a directory that *contains* a
-// node_modules; require.resolve({paths}) then looks under it.
-function fallbackBases() {
+function resolveLocalServer() {
+  const spec = '@ours.network/mcp/dist/cli.js';
+  try { return require.resolve(spec); } catch { /* try plugin cache layouts */ }
   const bases = [];
-  // Walk up from this file looking for a sibling `npm-cache` (the shared
-  // plugin-dependency tree Claude Code populates on some versions).
   let dir = here;
-  for (let i = 0; i < 12; i++) {
+  for (let index = 0; index < 12; index += 1) {
     const shared = join(dir, 'npm-cache');
     if (existsSync(join(shared, 'node_modules'))) bases.push(shared);
     const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  // Documented per-plugin persistent data dir (SessionStart-installed deps).
-  const dataDir = process.env.CLAUDE_PLUGIN_DATA;
-  if (dataDir) bases.push(dataDir);
-  return bases;
+  if (env.CLAUDE_PLUGIN_DATA) bases.push(env.CLAUDE_PLUGIN_DATA);
+  for (const base of bases) {
+    try { return require.resolve(spec, { paths: [base] }); } catch { /* next */ }
+  }
+  return null;
 }
 
-let cliPath;
-try {
-  // Per-version node_modules + ancestor walk-up.
-  cliPath = require.resolve(SPEC);
-} catch {
-  for (const base of fallbackBases()) {
-    try {
-      cliPath = require.resolve(SPEC, { paths: [base] });
-      break;
-    } catch {
-      // try the next candidate
+function relayChild(child, label) {
+  child.on('error', (error) => {
+    process.stderr.write(`ours: cannot launch ${label}: ${error.message}\n`);
+    process.exitCode = 1;
+  });
+  child.on('exit', (code, signal) => {
+    if (signal) process.kill(process.pid, signal);
+    else process.exitCode = code ?? 0;
+  });
+}
+
+async function main() {
+  const network = await import('../dist/network-client.mjs');
+  const profile = network.hostProfileFromEnv(env);
+  if (profile) {
+    const configPath = env.OURS_MCP_CONFIG || join(env.HOME || homedir(), '.ours-mcp', 'config.json');
+    const hostRecordRoot = dirname(configPath);
+    if (sessionEnd) {
+      const payload = JSON.parse(readFileSync(0, 'utf8') || '{}');
+      if (typeof payload.session_id !== 'string' || !payload.session_id) throw new Error('SessionEnd requires session_id.');
+      await network.endNetworkNativeSession({ profile, nativeSessionId: payload.session_id, hostRecordRoot });
+      return;
+    }
+    const nativeSessionId = env.CLAUDE_CODE_SESSION_ID;
+    if (watch) {
+      await network.runNetworkWatch({ identity: process.argv[3], nativeSessionId, profile, hostRecordRoot, env });
+      return;
+    }
+    await network.runNetworkProxy({ nativeSessionId, profile, hostRecordRoot, env });
+    return;
+  }
+
+  const container = containerInvocation(watch ? 'watch' : command, watch ? process.argv.slice(3) : forwarded, env);
+  if (container) {
+    const child = watch || sessionEnd
+      ? spawn(container.command, container.args, { stdio: watch ? ['pipe', 'inherit', 'inherit'] : 'inherit', env: container.env })
+      : runContainerProxy(container);
+    if (watch) {
+      const stop = () => { child.stdin?.end(); if (!child.killed) child.kill('SIGTERM'); };
+      process.on('SIGINT', stop);
+      process.on('SIGTERM', stop);
     }
+    if (watch || sessionEnd) relayChild(child, 'container MCP');
+    return;
   }
-}
 
-if (!cliPath) {
-  process.stderr.write(
-    'ours: cannot resolve @ours.network/mcp (the MCP server dependency). ' +
-      'Reinstall the ours plugin so its dependency is installed.\n',
-  );
-  process.exit(1);
+  const cliPath = resolveLocalServer();
+  if (!cliPath) {
+    throw new Error('cannot resolve @ours.network/mcp. Install the main MCP server explicitly or select an ours host network profile.');
+  }
+  if (!env.OURS_CLIENT_PID && process.ppid > 1) env.OURS_CLIENT_PID = String(process.ppid);
+  const child = spawn(process.execPath, [cliPath, command, ...forwarded], { stdio: 'inherit', env });
+  relayChild(child, 'the proxy');
 }
 
-// process.ppid here is the MCP client (Claude Code) that launched this shim.
-// Pass it so the daemon pid-checks the CLIENT's liveness (which survives idle),
-// not the connector's (which Claude tears down on idle).
-// Only forward the pid when it is > 1; on macOS, orphaned processes are reparented
-// to launchd (pid 1) and pidAlive(1) is always true — skip it in that case.
-const env = { ...process.env };
-if (!env.OURS_CLIENT_PID && process.ppid > 1) env.OURS_CLIENT_PID = String(process.ppid);
-const sessionEnd = process.argv[2] === 'session-end';
-const command = sessionEnd ? 'session-end' : 'proxy';
-const forwarded = process.argv.slice(sessionEnd ? 3 : 2);
-const child = spawn(
-  process.execPath,
-  [cliPath, command, ...forwarded],
-  { stdio: 'inherit', env },
-);
-
-child.on('error', (err) => {
-  process.stderr.write(`ours: failed to launch the proxy: ${String(err)}\n`);
-  process.exit(1);
-});
-child.on('exit', (code, signal) => {
-  if (signal) process.kill(process.pid, signal);
-  else process.exit(code ?? 0);
+main().catch((error) => {
+  process.stderr.write(`ours: ${error.message}\n`);
+  process.exitCode = 1;
 });