@cairnkeep/cli 2.25.0 → 2.27.0

package/scripts/test-team-installed.mjs

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, existsSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+// The caller passes the ACTUAL installed package, never a source-relative dist.
+const root = resolve(process.argv[2]);
+const { openTeamStore } = await import(pathToFileURL(join(root, 'mcp-memory-server/dist/team-store.js')));
+const { createTeamHttpServer } = await import(pathToFileURL(join(root, 'mcp-memory-server/dist/team-http.js')));
+const { hardenPrivatePath } = await import(pathToFileURL(join(root, 'mcp-memory-server/dist/platform-security.js')));
+const exec = promisify(execFile);
+const base = realpathSync(mkdtempSync(join(tmpdir(), 'cairn-installed-team-'))); hardenPrivatePath(base);
+const project = join(base, 'project with spaces'); mkdirSync(project, { mode: 0o700 }); hardenPrivatePath(project);
+const home = join(base, 'home'); mkdirSync(home, { mode: 0o700 }); hardenPrivatePath(home);
+const data = join(base, 'store');
+process.env.CAIRN_TEAM = '1'; process.env.CAIRN_TEAM_HTTP = '1';
+let store, server;
+try {
+  store = await openTeamStore(data, { create: true, organization: 'trial-org' });
+  await store.admin({ operation: 'project-create', project: 'trial-project' });
+  await store.admin({ operation: 'member-set', subject: 'reader', project: 'trial-project', roles: ['reader'] });
+  const credential = await store.issue({ subject: 'reader', credential_class: 'workload', expires_at: new Date(Date.now() + 3600000).toISOString() });
+  const tokenFile = join(base, 'reader.token'); writeFileSync(tokenFile, credential.token, { mode: 0o600 }); hardenPrivatePath(tokenFile);
+  const original = '{"mcpServers":{"cairn-memory":{"command":"personal-unchanged"},"other":{"command":"other-unchanged"}}}\n';
+  const config = join(project, '.mcp.json'); writeFileSync(config, original, { mode: 0o600 });
+  server = createTeamHttpServer(store); await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('CAIRN_')));
+  Object.assign(env, { HOME: home, USERPROFILE: home, CAIRN_TEAM: '1' });
+  const run = args => exec(process.execPath, [join(root, 'bin/cairn'), 'team', ...args], { env, cwd: base, timeout: process.platform === 'win32' ? 120000 : 30000, maxBuffer: 32768 });
+  const args = ['connect', '--project-root', project, '--organization', 'trial-org', '--project', 'trial-project', '--url', `http://127.0.0.1:${server.address().port}`, '--token-file', tokenFile, '--harness', 'claude'];
+  assert.match((await run(['connect', '--help'])).stdout, /no-write plan/);
+  const plan = await run(args); assert.equal(JSON.parse(plan.stdout).planned, true);
+  assert.equal(readFileSync(config, 'utf8'), original, 'installed no-apply preserves exact bytes');
+  await run([...args, '--apply', '--yes']);
+  const doctor = await run(['doctor', '--client', '--project-root', project]);
+  assert.equal(JSON.parse(doctor.stdout).ok, true);
+  assert.equal(doctor.stdout.includes(credential.token), false);
+  assert.equal(existsSync(join(home, '.cairnkeep/team')), false, 'client diagnostics open no administrator store');
+  await run(['disconnect', '--project-root', project]);
+  assert.ok(JSON.parse(readFileSync(config, 'utf8')).mcpServers['cairn-team-memory'], 'disconnect plan is read-only');
+  await run(['disconnect', '--project-root', project, '--apply', '--yes']);
+  assert.equal(readFileSync(config, 'utf8'), original, 'installed disconnect restores exact untouched original');
+  assert.equal(readFileSync(tokenFile, 'utf8'), credential.token);
+  Object.assign(env,{CAIRN_TEAM_URL:`http://127.0.0.1:${server.address().port}`,CAIRN_TEAM_ORGANIZATION:'trial-org',CAIRN_TEAM_TOKEN_FILE:tokenFile});
+  assert.deepEqual(JSON.parse((await run(['list','--project','trial-project','--page-size','1'])).stdout),{items:[],next_cursor:null});
+  await new Promise(r=>{server.close(r);server.closeAllConnections();});server=undefined;
+  const backup=join(base,'backup.json'),archive=join(base,'audit.json');
+  await run(['backup','--data',data,'--read-only','--output',backup]);
+  const exported=JSON.parse((await run(['audit-export','--data',data,'--backup',backup,'--output',archive])).stdout);
+  const archival=['audit-archive','--data',data,'--backup',backup,'--input',archive,'--confirm',exported.archive_digest];
+  assert.equal(JSON.parse((await run(archival)).stdout).applied,false);
+  assert.equal(JSON.parse((await run([...archival,'--apply'])).stdout).applied,true);
+  assert.equal(JSON.parse((await run(['doctor','--data',data])).stdout).capacity.checkpoint.archive_digest,exported.archive_digest);
+  assert(existsSync(backup) && existsSync(archive));
+  console.log('PASS: actual installed team plan/connect/client doctor/disconnect, preserved MCPs and no admin store');
+} finally {
+  if (server) await new Promise(r => { server.close(r); server.closeAllConnections(); });
+  await store?.close(); rmSync(base, { recursive: true, force: true });
+}

package/scripts/test-team-lab-env.mjs

@@ -0,0 +1,9 @@
+import assert from 'node:assert/strict';
+import {teamLabEnvironment} from '../mcp-memory-server/scripts/team-lab-env.mjs';
+const env=teamLabEnvironment('/private/lab',{CAIRN_TEAM:'1'},{Path:'system-path',SYSTEMROOT:'windows-root',ComSpec:'system-shell',WINDIR:'windows-dir',PATHEXT:'.EXE',PSModulePath:'system-modules',LOCALAPPDATA:'os-local',USERDOMAIN:'os-domain',CAIRN_TEAM_BASE_DIR:'production',CAIRN_LLM_API_KEY:'secret',PROVIDER_API_KEY:'secret',HOME:'real-home'});
+assert.equal(env.PATH,'system-path');assert.equal(env.SystemRoot,'windows-root');assert.equal(env.ComSpec,'system-shell');assert.equal(env.WINDIR,'windows-dir');assert.equal(env.PATHEXT,'.EXE');
+assert.equal(env.PSModulePath,'system-modules');assert.equal(env.LOCALAPPDATA,'os-local');assert.equal(env.USERDOMAIN,'os-domain');
+for(const key of ['HOME','USERPROFILE','TEMP','TMP'])assert.equal(env[key],'/private/lab');
+assert.equal(env.CAIRN_TEAM,'1');
+for(const key of ['CAIRN_TEAM_BASE_DIR','CAIRN_LLM_API_KEY','PROVIDER_API_KEY'])assert.equal(env[key],undefined);
+console.log('PASS: isolated team lab keeps Windows bootstrap variables, not production stores or provider secrets');

package/scripts/test-team-operations.mjs

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {teamLabEnvironment} from '../mcp-memory-server/scripts/team-lab-env.mjs';
+
+const lab=mkdtempSync(join(tmpdir(),'cairn-team-endurance-contract-'));
+try {
+  const script=resolve('mcp-memory-server/scripts/run-team-continuity-soak.mjs');
+  const out=join(lab,'report.json');
+  const env=teamLabEnvironment(lab);
+  const run=(args,enabled=false)=>spawnSync(process.execPath,[script,...args],{env:{...env,...(enabled?{CAIRN_TEAM_SOAK:'1'}:{})},encoding:'utf8',timeout:60000,maxBuffer:1024*1024});
+  assert.equal(run(['--help']).status,0);
+  assert.notEqual(run(['--out',out]).status,0,'endurance must be explicitly enabled');
+  assert.equal(existsSync(out),false);
+  const result=run(['--cycles','24','--duration-ms','0','--out',out],true);
+  assert.equal(result.status,0,result.stderr);
+  const report=JSON.parse(readFileSync(out,'utf8'));
+  assert.equal(report.result,'PASS');assert.equal(report.cycles,24);
+  assert.equal(report.agent_identities,2);assert.equal(report.api_process_restart_verified,true);
+  assert.equal(report.unclean_restart_verified,true);assert.equal(report.restores,1);assert.equal(report.audit_archives,1);
+  assert(report.credential_rotations>=2);assert(report.revocations_verified>=4);
+  for(const name of ['human_consent_claim','model_quality_claim','native_harness_ui_verified','production_configuration_changed'])assert.equal(report[name],false);
+  assert.equal(report.synthetic_only,true);assert.equal(report.paid_model_calls,0);
+  const bytes=readFileSync(out);
+  assert.notEqual(run(['--cycles','4','--duration-ms','0','--out',out],true).status,0,'reports are exclusive and cannot overwrite evidence');
+  assert.deepEqual(readFileSync(out),bytes);
+  assert.equal(existsSync(join(lab,'.cairnkeep')),false,'synthetic test must not create a real user store');
+  console.log('PASS: opt-in synthetic endurance, two MCP processes, API crash/restart, rotation, archive/restore and exclusive reports');
+} finally {rmSync(lab,{recursive:true,force:true});}

package/scripts/test-team-operations.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$ROOT"
+node scripts/test-team-operations.mjs

package/scripts/test-team-pilot.mjs

@@ -1,10 +1,11 @@
 import assert from 'node:assert/strict';
 import { createHash } from 'node:crypto';
-import { spawnSync } from 'node:child_process';
+import { execFile, spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
 import { readStableFile } from './lib/stable-file.mjs';
 
 if (process.platform === 'win32') {
@@ -15,6 +16,9 @@ const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const guide = readFileSync(join(root, 'docs/team-pilot.md'), 'utf8');
 const blocks = [...guide.matchAll(/<!-- team-pilot-setup:start -->\s*```sh\n([\s\S]*?)```\s*<!-- team-pilot-setup:end -->/g)];
 assert.equal(blocks.length, 1, 'exactly one maintained executable setup block');
+const onboarding = readFileSync(join(root, 'docs/team-onboarding.md'), 'utf8');
+const readerBlocks = [...onboarding.matchAll(/<!-- team-reader-check:start -->\s*```sh\n([\s\S]*?)```\s*<!-- team-reader-check:end -->/g)];
+assert.equal(readerBlocks.length, 1, 'exactly one maintained reader check');
 const hash = bytes => createHash('sha256').update(bytes).digest('hex');
 const productionPaths = ['.codex/config.toml', '.claude.json', '.qwen/settings.json',
   '.qwen/trustedFolders.json', '.config/opencode/opencode.json'];
@@ -52,7 +56,45 @@ try {
   const retry = execute();
   assert.notEqual(retry.status, 0, 'existing lab must not be reused or overwritten');
   assert.deepEqual(files.map(name => hash(readToken(name))), hashes);
+  const previousTeam = process.env.CAIRN_TEAM;
+  let store, server;
+  try {
+    process.env.CAIRN_TEAM = '1';
+    const { openTeamStore } = await import('../mcp-memory-server/dist/team-store.js');
+    const { createTeamHttpServer } = await import('../mcp-memory-server/dist/team-http.js');
+    store = await openTeamStore(join(pilot, 'store'));
+    const previousHttp = process.env.CAIRN_TEAM_HTTP;
+    try {
+      process.env.CAIRN_TEAM_HTTP = '1';
+      server = createTeamHttpServer(store);
+    } finally {
+      if (previousHttp === undefined) delete process.env.CAIRN_TEAM_HTTP;
+      else process.env.CAIRN_TEAM_HTTP = previousHttp;
+    }
+    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
+    const readerEnvironment = { ...environment, TEAM_PILOT_URL: `http://127.0.0.1:${server.address().port}` };
+    // Asynchronous child execution lets the parent serve the real API request.
+    const runReader = (extra = '', env = readerEnvironment) => promisify(execFile)('bash', ['-c', readerBlocks[0][1] + extra], {
+      cwd: base, env, timeout: 30000, maxBuffer: 16384,
+    });
+    const reader = await runReader();
+    assert.deepEqual(JSON.parse(reader.stdout), [], 'reader lists no unapproved content');
+    for (const name of files) {
+      const token = readToken(name).toString('utf8').trim();
+      assert.equal((reader.stdout + reader.stderr).includes(token), false);
+    }
+    await assert.rejects(runReader('\nteam_pilot_reader proposals\n'), error => error.code === 1 && /denied/.test(error.stderr));
+    const { TEAM_PILOT_URL, ...missingUrl } = readerEnvironment;
+    await assert.rejects(runReader('', missingUrl), error => error.code !== 0 && /TEAM_PILOT_URL/.test(error.stderr));
+    assert.deepEqual(files.map(name => hash(readToken(name))), hashes, 'reader check does not rewrite credentials');
+  } finally {
+    if (server) { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+    await store?.close();
+    if (previousTeam === undefined) delete process.env.CAIRN_TEAM;
+    else process.env.CAIRN_TEAM = previousTeam;
+  }
   assert.deepEqual(fingerprint(), before, 'production harness configurations unchanged');
+  console.log('PASS: documented real reader request, server role denial, required inputs and credential preservation');
   console.log('PASS: documented pilot setup, isolated identities, private credentials, no token output and no overwrite');
 } finally {
   rmSync(base, { recursive: true, force: true });

package/scripts/verify-published-release.mjs

@@ -65,6 +65,14 @@ async function bytesFrom(url, maxBytes, headers = {}, blobRedirects = false) {
 const parse = bytes => JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
 const digest = bytes => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
 
+export function npmVerificationCommands(prefix, version) {
+  const fresh = ['--cache', join(prefix, '.verification-cache'), '--prefer-online', '--prefer-offline=false', '--offline=false', '--registry', 'https://registry.npmjs.org'];
+  return [
+    ['install', '--prefix', prefix, `@cairnkeep/cli@${version}`, '--ignore-scripts', '--no-audit', '--no-fund', ...fresh],
+    ['audit', 'signatures', '--prefix', prefix, ...fresh],
+  ];
+}
+
 async function main(args) {
   if (args.length === 1 && ["--help", "-h"].includes(args[0])) { console.log(usage); return; }
   const options = optionsFrom(args);
@@ -95,12 +103,13 @@ async function main(args) {
       tarball: async url => bytesFrom(url, 64 * 1024 * 1024),
       verifyNpm: async tarball => {
         const prefix = join(scratch, "npm");
-        run(npm, ["install", "--prefix", prefix, `@cairnkeep/cli@${expected.version}`, "--ignore-scripts", "--no-audit", "--no-fund", "--registry", "https://registry.npmjs.org"]);
+        const [install, audit] = npmVerificationCommands(prefix, expected.version);
+        run(npm, install);
         const lock = parse(readStableFile(join(prefix, "package-lock.json"), { label: "Verification install lock", maxBytes: 8 * 1024 * 1024 }).bytes);
         if (lock.packages?.["node_modules/@cairnkeep/cli"]?.integrity !== `sha512-${createHash("sha512").update(tarball).digest("base64")}`) {
           throw new Error("Release verification failed: audited package/candidate binding.");
         }
-        const audited = run(npm, ["audit", "signatures", "--prefix", prefix, "--registry", "https://registry.npmjs.org"]);
+        const audited = run(npm, audit);
         return /[1-9][0-9]* packages have verified registry signatures/.test(audited)
           && /[1-9][0-9]* packages have verified attestations/.test(audited);
       },

package/scripts/verify-security-baseline.mjs

@@ -33,6 +33,25 @@ function walk(value, visit, path = "workflow") {
     }
 }
 
+export function validateCodeqlCohort(workflows, dependabot) {
+    const references = [];
+    for (const workflow of workflows) walk(workflow, (key, value) => {
+        if (key === "uses" && typeof value === "string" && value.startsWith("github/codeql-action/")) {
+            assert.match(value, /^github\/codeql-action\/[^@\s]+@[a-f0-9]{40}$/, "CodeQL actions must be pinned to a full commit");
+            references.push(value);
+        }
+    });
+    assert.ok(references.length > 0, "CodeQL cohort is missing");
+    assert.equal(new Set(references.map(value => value.split("@")[1])).size, 1, "CodeQL cohort must use the same commit across workflows");
+    for (const action of ["init", "analyze", "upload-sarif"]) {
+        assert.ok(references.some(value => value.startsWith(`github/codeql-action/${action}@`)), `CodeQL cohort is missing ${action}`);
+    }
+    const updates = dependabot?.updates?.filter(update => update["package-ecosystem"] === "github-actions" && update.directory === "/") ?? [];
+    assert.equal(updates.length, 1, "CodeQL cohort requires one root GitHub Actions update group");
+    const group = updates[0].groups?.["codeql-action"];
+    assert.deepEqual(group, { patterns: ["github/codeql-action/*"] }, "CodeQL dependency group must cover the entire cohort without exclusions or update-type restrictions");
+}
+
 function validateWorkflow(name, workflow) {
     assert.ok(workflow && typeof workflow === "object" && !Array.isArray(workflow), `${name} is not a workflow mapping`);
     assert.ok(workflow.permissions && typeof workflow.permissions === "object" && !Array.isArray(workflow.permissions), `${name} must have an explicit workflow permission mapping`);
@@ -123,6 +142,7 @@ for (const [index, [fixture, expected]] of maliciousFixtures.entries()) {
 
 for (const { name, workflow } of sources) validateWorkflow(name, workflow);
 validatePublicationPermissions(publish);
+validateCodeqlCohort(sources.map(source => source.workflow), parse(readFileSync(join(root, ".github", "dependabot.yml"), "utf8")));
 
 const security = sources.find(({ name }) => name === "security.yml")?.text ?? "";
 assert.match(security, /github\/codeql-action\/init@[a-f0-9]{40}/);

package/scripts/windows-platform.mjs

@@ -779,7 +779,7 @@ export function powershellCompletion() {
   $pack = 'init','lock','validate','install','import-okf','validate-okf','export-okf','list','show','remove','enable','disable','update','skills','approve-skill','revoke-skill','doctor','--repair','--project','--project-id','--json'
   $proposals = 'create','list','show','apply','doctor','--session','--scope','--model','--category','--project','--json'
   $security = 'doctor','--project','--json'
-  $team = 'init','project','member','credential','create','set','remove','issue','revoke','serve','mcp','list','read','search','history','propose','proposals','proposal-show','review','audit','doctor','backup','restore','memory-delete','--organization','--data','--project','--roles','--class','--expires-at','--output','--input','--confirm','--port','--key','--query','--proposal','--decision','--revision','--project-root'
+  $team = 'connect','disconnect','init','project','member','credential','create','set','remove','issue','revoke','serve','mcp','list','read','search','history','propose','proposals','proposal-show','review','audit','audit-export','audit-verify','audit-archive','doctor','backup','restore','memory-delete','--backup','--previous','--page-size','--cursor','--read-only','--organization','--data','--project','--roles','--class','--expires-at','--output','--input','--confirm','--port','--key','--query','--proposal','--decision','--revision','--project-root','--connection','--client','--url','--token-file','--harness','--access','--apply','--yes'
   $evaluation = 'validate','run','ablate','report','prune','delete','protocol','--task-set','--adapter','--output','--repetitions','--seed','--yes','--json','--disable','--experiment','--older-than-days','--dry-run','--trajectory','--codex-jsonl','--capture-authorized'
   $candidates = if ($commandAst.ToString() -match '^\\s*cairn\\s+setup(?:\\s|$)') { $setup } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+team(?:\\s|$)') { $team } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+playbook(?:\\s|$)') { $playbook } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+pack(?:\\s|$)') { $pack } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+proposals(?:\\s|$)') { $proposals } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+security(?:\\s|$)') { $security } elseif ($commandAst.ToString() -match '^\\s*cairn\\s+eval(?:\\s|$)') { $evaluation } else { $commands }
   $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {