borgmcp 2.0.11 → 2.1.1

package/src/assimilate-deps.ts

@@ -25,10 +25,12 @@ import {
 } from './remote-client.js';
 import {
   DEFAULT_LOCAL_SERVER_ORIGIN,
+  associateLocalBorgServerRepositoryCube,
   connectLocalBorgServer,
   createLocalBorgServerCube,
   enrollLocalBorgServer,
   probeLocalBorgServer,
+  resolveLocalBorgServerRepositoryCube,
   resumeLocalBorgServerEnrollment,
   sendBorgServerAttach,
 } from './server-handshake.js';
@@ -45,7 +47,7 @@ import {
 } from './cubes.js';
 import { loadBorgServerTrust } from './server-trust.js';
 import { defaultProbeSeat } from './seat-probe.js';
-import { BorgServerError } from './server-errors.js';
+import { BorgServerError, CubeCreationConfirmationError } from './server-errors.js';
 import {
   findProjectRoot as cubesFindProjectRoot,
   getActiveCube as cubesGetActive,
@@ -61,8 +63,47 @@ import { prepareCodexRemoteLaunch, defaultCodexRemoteDeps } from './codex-remote
 import { findLoadedCodexThread } from './codex-app-server.js';
 import { defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { ensurePrivateBorgConfigRoot } from './private-root.js';
+import {
+  getOrCreateRepositoryIdentity,
+  getRepositoryAssociation,
+  resolveGitRepositoryContext,
+  saveRepositoryAssociation,
+} from './repository-identity.js';
+import { PromptInterruptedError } from './repository-cube-init.js';
+
+/**
+ * Wraps the readline question operation with the production interruption
+ * mapping. Tests inject the question operation; production uses readline.
+ */
+export type PromptQuestion = (message: string) => Promise<string>;
+
+async function defaultPromptQuestion(message: string): Promise<string> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(message);
+  } finally {
+    rl.close();
+  }
+}
+
+export function createPromptAdapter(
+  question: PromptQuestion = defaultPromptQuestion,
+): (message: string) => Promise<string> {
+  return async (message: string): Promise<string> => {
+    try {
+      return await question(message);
+    } catch (err) {
+      if (err instanceof Error && (err.message === 'SIGINT' || err.message === 'Interrupted by signal.')) {
+        throw new PromptInterruptedError();
+      }
+      throw err;
+    }
+  };
+}
 
-export function buildDefaultAssimilateDeps(): AssimilateDeps {
+export function buildDefaultAssimilateDeps(
+  question: PromptQuestion = defaultPromptQuestion,
+): AssimilateDeps {
   return {
     runSync: (cmd, args, cwd) => {
       const r = spawnSync(cmd, args, { cwd, encoding: 'utf-8' });
@@ -97,14 +138,7 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
 
     stderr: (line) => process.stderr.write(line),
     stdout: (line) => process.stdout.write(line),
-    prompt: async (message: string): Promise<string> => {
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      try {
-        return await rl.question(message);
-      } finally {
-        rl.close();
-      }
-    },
+    prompt: createPromptAdapter(question),
     promptSecret: async (message: string): Promise<string> => {
       const result = await prompts({
         type: 'password',
@@ -178,6 +212,10 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         : { committed: false, reason: 'activation-failed' };
     },
     findProjectRoot: (cwd) => cubesFindProjectRoot(cwd),
+    resolveRepositoryContext: resolveGitRepositoryContext,
+    getRepositoryIdentity: getOrCreateRepositoryIdentity,
+    getRepositoryAssociation,
+    saveRepositoryAssociation,
 
     // gh#673 P2 (WI-1): project-local SessionStart hook for the launch root.
     installProjectSessionHook: (projectRoot) => {
@@ -202,6 +240,29 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         ...(onPending === undefined ? {} : { onPending }),
       }),
 
+    resolveRepositoryCube: async (apiUrl, token, input, serverTrustIdentity) => {
+      if (serverTrustIdentity === undefined) {
+        throw new Error('Selected Borg server authority state is missing or unreadable');
+      }
+      return resolveLocalBorgServerRepositoryCube(
+        apiUrl,
+        serverTrustIdentity,
+        token,
+        input,
+      );
+    },
+    associateRepositoryCube: async (apiUrl, token, input, serverTrustIdentity) => {
+      if (serverTrustIdentity === undefined) {
+        throw new Error('Selected Borg server authority state is missing or unreadable');
+      }
+      return associateLocalBorgServerRepositoryCube(
+        apiUrl,
+        serverTrustIdentity,
+        token,
+        input,
+      );
+    },
+
     listCubes: async (apiUrl, token, serverTrustIdentity) => {
       if (serverTrustIdentity === undefined) {
         throw new Error('Selected Borg server authority state is missing or unreadable');
@@ -237,32 +298,43 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
         throw new Error('Selected Borg server authority state is missing or unreadable');
       }
       {
-        if (!params.name || !params.projectRoot) {
-          throw new Error('Local Borg server cube creation requires a repository name and root');
-        }
         const created = await createLocalBorgServerCube(
           apiUrl,
           serverTrustIdentity,
           token,
-          { projectRoot: params.projectRoot, name: params.name },
+          {
+            name: params.name,
+            workingRepoName: params.workingRepoName,
+            repository: params.repository,
+            template: params.template,
+          },
         );
-        const cube = await remoteGetCube(created.cube_id, {
-          apiUrl,
-          authToken: token,
-          serverTrustIdentity,
-        });
+        let cube;
+        try {
+          cube = await remoteGetCube(created.cube_id, {
+            apiUrl,
+            authToken: token,
+            serverTrustIdentity,
+          });
+        } catch {
+          throw new CubeCreationConfirmationError('The server returned a cube result that could not be read back.');
+        }
         if (
           cube.id !== created.cube_id ||
+          cube.name !== created.name ||
           !Array.isArray(cube.roles) ||
           !cube.roles.some((role: { id?: string }) => role.id === created.default_worker_role_id)
         ) {
-          throw new Error('Borg server returned cube details outside the creation result');
+          throw new CubeCreationConfirmationError('The server returned cube details outside the creation result.');
         }
         return {
-          id: cube.id,
-          name: cube.name,
-          roles: cube.roles,
-          drones: cube.drones ?? [],
+          response: created,
+          cube: {
+            id: cube.id,
+            name: cube.name,
+            roles: cube.roles,
+            drones: cube.drones ?? [],
+          },
         };
       }
     },

package/src/claude.ts

@@ -19,8 +19,10 @@
 
 import { spawn } from 'child_process';
 import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
 import { basename } from 'node:path';
 import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import { findProjectRoot, getActiveCube, inboxPathForDrone, setCodexWakeTarget, pruneDeadCodexWakeTargets } from './cubes.js';
 import { monitorStateRootForWorktree } from './inbox-monitor.js';
@@ -81,6 +83,23 @@ import { connectOpenCodeDrone, computeOpenCodePort, createOpenCodeLaunchKickoff,
 import { buildOpenCodeLaunchArgs, defaultApprovalIo, resolveLaunchBorgApprovals } from './cli-tool-approval.js';
 import { runEarlyServerFacade } from './server-facade.js';
 
+export type AssimilateDepsBuilder = typeof buildDefaultAssimilateDeps;
+
+export async function runAssimilateEntry(
+  args: readonly string[],
+  buildDeps: AssimilateDepsBuilder = buildDefaultAssimilateDeps,
+): Promise<number> {
+  const parsed = parseAssimilateArgs([...args]);
+  if (!parsed.ok) {
+    process.stderr.write(
+      chalk.red(`${consolePrefix()}◼ borg assimilate: ${parsed.error}\n`)
+    );
+    process.stderr.write(`Run \`borg --help\` for usage.\n`);
+    return 1;
+  }
+  return runAssimilate({ role: parsed.role, flags: parsed.flags }, buildDeps());
+}
+
 async function main() {
   const serverExitCode = await runEarlyServerFacade(process.argv);
   if (serverExitCode !== null) process.exit(serverExitCode);
@@ -128,16 +147,7 @@ async function main() {
       process.stdout.write(assimilateHelpText(getPackageVersion()));
       process.exit(0);
     }
-    const parsed = parseAssimilateArgs(process.argv.slice(3));
-    if (!parsed.ok) {
-      process.stderr.write(
-        chalk.red(`${consolePrefix()}◼ borg assimilate: ${parsed.error}\n`)
-      );
-      process.stderr.write(`Run \`borg --help\` for usage.\n`);
-      process.exit(1);
-    }
-    const deps = buildDefaultAssimilateDeps();
-    const code = await runAssimilate({ role: parsed.role, flags: parsed.flags }, deps);
+    const code = await runAssimilateEntry(process.argv.slice(3));
     process.exit(code);
   }
   if (process.argv[2] === 'reset-local-seat') {
@@ -560,7 +570,17 @@ function ensureDetectedCliConfigured(): void {
   }
 }
 
-main().catch((error) => {
-  console.error(`${consolePrefix()}${chalk.red(`\n◼ Error: ${error.message}\n`)}`);
-  process.exit(1);
-});
+function isEntryInvocation(): boolean {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+if (isEntryInvocation()) {
+  main().catch((error) => {
+    console.error(`${consolePrefix()}${chalk.red(`\n◼ Error: ${error.message}\n`)}`);
+    process.exit(1);
+  });
+}

package/src/cli-help.ts

@@ -30,6 +30,7 @@ export function topLevelHelpText(version: string): string {
     `  borg assimilate [role]   Join or create a cube\n` +
     `  borg assimilate --host <host>   Join or create on an explicit server\n` +
     `  borg assimilate --worktree <name>   Spawn a worktree drone (in ~/.borg/worktrees/<repo>/<name>)\n` +
+    `  borg server cube init   Initialize this repository's cube without creating a drone\n` +
     `  borg reset-local-seat    Clear ONLY this worktree's saved local seat (offline; after a rejection)\n` +
     `  borg sync [--prune]      Sync this worktree's branch to origin/main\n` +
     `  borg cleanup [--prune]   Report (or --prune) worktrees orphaned by evicted drones\n` +
@@ -53,11 +54,28 @@ export function serverHelpText(): string {
     `  stop     Stop the managed local server.\n` +
     `  status   Report verified runtime evidence.\n` +
     `  update   Verify and activate a local server artifact.\n` +
-    `  invite   Create a single-use invitation in an interactive terminal.\n\n` +
+    `  invite   Create a single-use invitation in an interactive terminal.\n` +
+    `  cube init   Initialize this Git repository's cube; does not create a drone.\n\n` +
     `Run borg server <command> --help for server command options.\n`
   );
 }
 
+/** Client-owned help for repository cube initialization without a drone. */
+export function cubeInitHelpText(): string {
+  return (
+    `borg server cube init — initialize this Git repository's cube without creating a drone\n\n` +
+    `Usage:\n` +
+    `  borg server cube init [options]\n\n` +
+    `Options:\n` +
+    `  --host <host>                    Borg server host or URL (bare hosts default to HTTPS)\n` +
+    `  --enroll                         Prompt for a hidden enrollment invitation\n` +
+    `  --cube-name <name>               Repository cube name (otherwise edit the proposed name)\n` +
+    `  --template software-dev|starter  New-cube template (default: software-dev)\n` +
+    `  --yes, -y                        Accept new-cube defaults; never adopt by name\n` +
+    `  --help, -h                       Show this help\n`
+  );
+}
+
 /**
  * Help text for `borg assimilate --help` — the home for the full assimilate flag
  * set. Model/provider configuration belongs to the selected agent CLI.
@@ -76,16 +94,19 @@ export function assimilateHelpText(version: string): string {
     `Flags:\n` +
     `  --worktree <name>          Create + launch the drone in a sibling git worktree\n` +
     `  --here                     Stay in the current worktree (no sibling spawn)\n` +
-    `  --cube-name <name>         Cube to join/create (otherwise confirm repo basename)\n` +
+    `  --cube-name <name>         Repository cube name (otherwise edit the proposed name)\n` +
     `  --host <host>              Borg server host or URL (bare hosts default to HTTPS)\n` +
     `  --enroll                   Prompt for a hidden enrollment invitation in the operator terminal\n` +
-    `  --template <name>          Bootstrap a new cube from a bundled role template\n` +
-    `  --no-template              Create the cube with no template roles\n` +
+    `  --template software-dev|starter   New-cube template (default: software-dev)\n` +
+    `  --no-template              Unsupported for repository cube creation\n` +
     `  --cli claude|codex|opencode         Agent CLI to launch (default: claude)\n` +
     `  --model claude:<model>   Legacy Claude model override (configure models in the agent CLI)\n` +
-    `  --yes, -y                  Skip confirmation prompts\n\n` +
-    `An enrolled owner client may create an idempotent repository cube; ordinary clients\n` +
-    `require an explicit cube grant. Agent seats begin only after enrollment. Preview only.\n` +
+    `  --yes, -y                  Accept new-cube defaults; never adopt by name\n\n` +
+    `Creation shows repository context, name, template, and one confirmation. An existing\n` +
+    `repository association skips all prompts. One accessible exact-name legacy cube requires\n` +
+    `explicit interactive adoption; ambiguous matches fail closed. An enrolled owner client may\n` +
+    `create an idempotent repository cube; ordinary clients require an explicit cube grant.\n` +
+    `Agent seats begin only after enrollment. Preview only.\n` +
     `See docs/LOCAL_SERVER.md for self-hosted setup and current status.\n\n` +
     `For local or provider-specific models, configure the selected agent CLI directly.\n` +
     `OpenCode supports Ollama and other providers through its own model configuration.\n`

package/src/config.ts

@@ -7,7 +7,7 @@
  * read-compare-write shared by client enrollment and same-machine server setup.
  */
 import { createHash, randomBytes, randomUUID } from 'crypto';
-import type { ServerCapability } from 'borgmcp-shared/protocol';
+import type { CreateCubeRepository, CubeTemplate, ServerCapability } from 'borgmcp-shared/protocol';
 import { withStoreLock } from './seat-store.js';
 import {
   makeFileBackend,
@@ -17,7 +17,7 @@ import { BORG_USER_ROOT, SERVER_CREDENTIALS_FILE } from './credential-paths.js';
 
 const SERVER_CREDENTIAL_RECORD_VERSION = 2 as const;
 const SERVER_PENDING_ENROLLMENT_RECORD_VERSION = 1 as const;
-const SERVER_CUBE_RETRY_RECORD_VERSION = 1 as const;
+const SERVER_CUBE_RETRY_RECORD_VERSION = 2 as const;
 // The 0600 credential store (Queen rescope: replaces the OS keychain). A single
 // file holds every parent credential/enrollment record; a single flock
 // serializes every mutator + observer that must (SR-seven #4).
@@ -57,7 +57,9 @@ export interface PendingServerCubeCreationRecord {
   repositoryBinding: string;
   retryKey: string;
   name: string;
-  template: 'default';
+  workingRepoName: string;
+  repository: CreateCubeRepository;
+  template: CubeTemplate;
 }
 
 /**
@@ -510,21 +512,29 @@ export async function getOrCreatePendingServerCubeCreation(
     origin: string;
     trustIdentity: string;
     clientId: string;
-    projectRoot: string;
     name: string;
-    template: 'default';
+    workingRepoName: string;
+    repository: CreateCubeRepository;
+    template: CubeTemplate;
   },
 ): Promise<PendingServerCubeCreationRecord> {
   validateServerCredentialBinding(input.origin, input.trustIdentity);
   validateUuid(input.clientId, 'client identity');
-  if (input.projectRoot.length < 1 || input.projectRoot.length > 4096 || /[\u0000-\u001f\u007f]/.test(input.projectRoot)) {
+  if (
+    (input.repository.kind !== 'origin' && input.repository.kind !== 'local') ||
+    typeof input.repository.value !== 'string' || input.repository.value.length < 1
+  ) {
     throw new Error('invalid Borg server repository binding');
   }
   if (Buffer.byteLength(input.name, 'utf8') < 1 || Buffer.byteLength(input.name, 'utf8') > 120 ||
       !/^[A-Za-z0-9][A-Za-z0-9 ._-]*$/.test(input.name)) {
     throw new Error('invalid Borg server cube name');
   }
-  const repositoryBinding = createHash('sha256').update(input.projectRoot).digest('hex');
+  const repositoryBinding = createHash('sha256')
+    .update(input.repository.kind)
+    .update('\0')
+    .update(input.repository.value)
+    .digest('hex');
   const backend = await getServerCredentialBackend();
   const account = serverCubeRetryAccount(
     input.origin,
@@ -548,6 +558,7 @@ export async function getOrCreatePendingServerCubeCreation(
           record.clientId !== input.clientId ||
           record.repositoryBinding !== repositoryBinding ||
           record.name !== input.name ||
+          record.workingRepoName !== input.workingRepoName ||
           record.template !== input.template ||
           typeof record.retryKey !== 'string' || !UUID_RE.test(record.retryKey)
         ) {
@@ -560,6 +571,8 @@ export async function getOrCreatePendingServerCubeCreation(
           repositoryBinding,
           retryKey: record.retryKey,
           name: input.name,
+          workingRepoName: input.workingRepoName,
+          repository: input.repository,
           template: input.template,
         };
       } catch {
@@ -573,12 +586,21 @@ export async function getOrCreatePendingServerCubeCreation(
       repositoryBinding,
       retryKey: randomUUID(),
       name: input.name,
+      workingRepoName: input.workingRepoName,
+      repository: input.repository,
       template: input.template,
     };
     await backend.set(account, JSON.stringify({
       version: SERVER_CUBE_RETRY_RECORD_VERSION,
       state: 'pending',
-      ...record,
+      origin: record.origin,
+      trustIdentity: record.trustIdentity,
+      clientId: record.clientId,
+      repositoryBinding: record.repositoryBinding,
+      retryKey: record.retryKey,
+      name: record.name,
+      workingRepoName: record.workingRepoName,
+      template: record.template,
     }));
     return record;
   });

package/src/remote-client.ts

@@ -712,7 +712,7 @@ async function authedFetch(
           parsed.error !== null && typeof parsed.error === 'object' &&
           parsed.error.code === ROLE_SECTION_CONFLICT_CODE
         ) {
-          // Shared 0.6.2 intentionally omits this server-local code. Re-validate the whole
+          // The shared protocol intentionally omits this server-local code. Re-validate the whole
           // envelope through the strict shared decoder with only the recognized
           // code substituted; no server-provided diagnostic is ever surfaced.
           decodeProtocolErrorEnvelope({