@north-light/crouter 0.3.313 → 0.3.314

package/dist/core/__tests__/integration/fresh-home-commands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/__tests__/integration/fresh-home-commands.test.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+const CLI = fileURLToPath(new URL('../../../cli.ts', import.meta.url));
+const ROOT = new URL('../../../build-root.ts', import.meta.url).href;
+const LOADER = import.meta.resolve('tsx/esm');
+test('command discovery initializes fresh homes and refuses legacy state without conversion', () => {
+    const commands = [
+        [CLI, '-h'],
+        [CLI, 'human', '-h'],
+        ['--input-type=module', '--eval', `import { coreCommandPaths } from ${JSON.stringify(ROOT)}; if (!(await coreCommandPaths()).has('human')) throw new Error('human command missing'); console.log('coreCommandPaths: human present');`],
+    ];
+    for (const legacy of [false, true])
+        for (const command of commands) {
+            const home = mkdtempSync(join(tmpdir(), 'crtr-command-home-'));
+            const config = join(home, '.crouter', 'config.json');
+            const database = join(home, '.crouter', 'operations.db');
+            try {
+                if (legacy) {
+                    mkdirSync(dirname(config), { recursive: true });
+                    writeFileSync(config, '{}\n');
+                }
+                const result = spawnSync(process.execPath, ['--conditions=crtr-src', '--import', LOADER, ...command], {
+                    cwd: home,
+                    env: { HOME: home, PATH: process.env.PATH, CRTR_NO_DAEMON_AUTOSTART: '1', CRTR_NO_AUTO_UPDATE: '1', CRTR_NO_EXPORTS: '1' },
+                    encoding: 'utf8',
+                    timeout: 15_000,
+                });
+                const detail = `${legacy ? 'legacy' : 'fresh'} HOME: ${command.join(' ')}\n${result.stdout}\n${result.stderr}`;
+                assert.ifError(result.error);
+                assert.equal(result.status, legacy ? 1 : 0, detail);
+                assert.equal(existsSync(database), !legacy, detail);
+                if (legacy) {
+                    assert.match(result.stderr, /legacy scoped state exists.*crtr sys daemon restart/s, detail);
+                    assert.equal(readFileSync(config, 'utf8'), '{}\n');
+                }
+                else {
+                    assert.notEqual(result.stdout.trim(), '', detail);
+                }
+            }
+            finally {
+                rmSync(home, { recursive: true, force: true });
+            }
+        }
+});

package/dist/core/command.js

@@ -641,6 +641,17 @@ export async function runCli(root, argv) {
         process.exitCode = ExitCode.SUCCESS;
         return;
     }
+    // `crtr --version` / `crtr -v`. The front door already routes both here, so
+    // without this branch they fall through to the unknown-path error below.
+    // Imported lazily: `sys/shared.js` locates the package root eagerly at module
+    // load, and the cold-start check forbids adding that to cli.js's static
+    // import closure.
+    if (tokens.length === 1 && (tokens[0] === '--version' || tokens[0] === '-v')) {
+        const { readPackageVersion } = await import('../commands/sys/shared.js');
+        process.stdout.write(readPackageVersion() + '\n');
+        process.exitCode = ExitCode.SUCCESS;
+        return;
+    }
     let { node, path, remaining } = walk(root, tokens);
     try {
         // Passthrough branches (e.g. `crtr capture`) opt out of the tree model

package/dist/core/scoped-state/db.d.ts

@@ -1,6 +1,17 @@
 import { DatabaseSync } from 'node:sqlite';
-import type { ScopedStore } from './paths.js';
+import { type ScopedStore } from './paths.js';
+export declare const PROFILE_ID_SHAPE: RegExp;
+export declare function writeOwnerRoot(db: DatabaseSync, key: string, root: string): void;
 export declare function scopedStoreExists(store: ScopedStore): boolean;
+export declare function legacyScopedStorePaths(store: ScopedStore): string[];
+/** Acquiring the store on demand races every other process reaching the same
+ *  fresh root at once (e.g. two brokers sharing a fresh agent dir on first
+ *  launch), so the check-then-create runs under a cross-process lock — the
+ *  same primitive worktree-sweep and the plugin-swap path already use. */
+export declare function initializeFreshScopedStore(input: {
+    kind: 'user' | 'project' | 'provider';
+    root: string;
+}): void;
 export declare function openScopedStore(store: ScopedStore): DatabaseSync;
 export declare function createScopedStore(store: ScopedStore, create: (db: DatabaseSync) => void): void;
 export declare function withScopedWrite<T>(store: ScopedStore, run: (db: DatabaseSync) => T): T;

package/dist/core/scoped-state/db.js

@@ -1,7 +1,15 @@
 import { DatabaseSync } from 'node:sqlite';
-import { chmodSync, existsSync, mkdirSync, statSync, writeFileSync } from 'node:fs';
-import { SCOPED_SCHEMA_VERSION } from './schema.js';
+import { chmodSync, existsSync, mkdirSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
+import { withExclusiveDirectoryLock } from '../exclusive-lock.js';
+import { providerStore, projectStore, userStore } from './paths.js';
+import { createScopedSchema, SCOPED_SCHEMA_VERSION } from './schema.js';
 const handles = new Map();
+export const PROFILE_ID_SHAPE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;
+export function writeOwnerRoot(db, key, root) {
+    db.prepare('UPDATE scope_owners SET root=? WHERE owner_key=?').run(root, key);
+}
 function version(db) {
     return Number(db.prepare('PRAGMA user_version').get().user_version);
 }
@@ -15,12 +23,47 @@ function secure(path) {
 export function scopedStoreExists(store) {
     return existsSync(store.path);
 }
+export function legacyScopedStorePaths(store) {
+    if (store.kind === 'project')
+        return [join(store.root, STATE_FILE)];
+    if (store.kind === 'provider')
+        return [join(store.root, 'anthropic-subscriptions.json'), join(store.root, 'openai-codex-subscriptions.json'), join(store.root, 'provider-rotation.json')];
+    const paths = [join(store.root, CONFIG_FILE), join(store.root, STATE_FILE), join(store.root, 'profile-defaults.json')];
+    const profiles = join(store.root, PROFILE_DIR);
+    if (existsSync(profiles))
+        for (const entry of readdirSync(profiles, { withFileTypes: true }))
+            if (entry.isDirectory() && PROFILE_ID_SHAPE.test(entry.name))
+                paths.push(join(profiles, entry.name, 'profile.json'), join(profiles, entry.name, CONFIG_FILE), join(profiles, entry.name, STATE_FILE));
+    return paths;
+}
+/** Acquiring the store on demand races every other process reaching the same
+ *  fresh root at once (e.g. two brokers sharing a fresh agent dir on first
+ *  launch), so the check-then-create runs under a cross-process lock — the
+ *  same primitive worktree-sweep and the plugin-swap path already use. */
+export function initializeFreshScopedStore(input) {
+    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
+    if (scopedStoreExists(store))
+        return;
+    mkdirSync(store.root, { recursive: true, mode: 0o700 });
+    withExclusiveDirectoryLock(join(store.root, '.init.lock'), () => {
+        if (scopedStoreExists(store))
+            return;
+        const legacyPath = legacyScopedStorePaths(store).find(existsSync);
+        if (legacyPath !== undefined)
+            throw new Error(`legacy scoped state exists at ${legacyPath}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+        createScopedStore(store, (db) => {
+            createScopedSchema(db, store.kind);
+            if (store.kind !== 'provider')
+                writeOwnerRoot(db, store.kind, store.root);
+        });
+    });
+}
 export function openScopedStore(store) {
     const cached = handles.get(store.path);
     if (cached !== undefined)
         return cached;
     if (!existsSync(store.path))
-        throw new Error(`scoped SQL store is not initialized: ${store.path}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
+        initializeFreshScopedStore(store);
     const db = new DatabaseSync(store.path);
     db.exec('PRAGMA busy_timeout = 5000; PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;');
     const found = version(db);

package/dist/core/scoped-state/migrate.d.ts

@@ -1,7 +1,4 @@
-export declare function initializeFreshScopedStore(input: {
-    kind: 'user' | 'project' | 'provider';
-    root: string;
-}): void;
+export { initializeFreshScopedStore } from './db.js';
 /** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
 export declare function convertLegacyScopedStore(input: {
     kind: 'user' | 'project' | 'provider';

package/dist/core/scoped-state/migrate.js

@@ -4,10 +4,9 @@ import { dirname, join, relative } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { CONFIG_FILE, PROFILE_DIR, STATE_FILE } from '../../types.js';
 import { LockedJsonFile } from '../locked-file.js';
-import { createScopedStore, scopedStoreExists } from './db.js';
+import { createScopedStore, legacyScopedStorePaths, PROFILE_ID_SHAPE, scopedStoreExists, writeOwnerRoot } from './db.js';
 import { providerStore, projectStore, userStore } from './paths.js';
 import { createScopedSchema } from './schema.js';
-function writeOwnerRoot(db, key, root) { db.prepare('UPDATE scope_owners SET root=? WHERE owner_key=?').run(root, key); }
 function json(path) { return JSON.parse(readFileSync(path, 'utf8')); }
 function existsLegacy(paths) { return paths.some(existsSync); }
 function preserve(root, paths) { const target = join(root, '.legacy-scoped-state'); mkdirSync(target, { recursive: true, mode: 0o700 }); chmodSync(target, 0o700); for (const path of paths)
@@ -20,12 +19,6 @@ function preserve(root, paths) { const target = join(root, '.legacy-scoped-state
         copyFileSync(path, destination);
         chmodSync(destination, 0o600);
     } }
-const PROFILE_ID_SHAPE = /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/;
-function userLegacyPaths(root) { const out = [join(root, CONFIG_FILE), join(root, STATE_FILE), join(root, 'profile-defaults.json')]; const profiles = join(root, PROFILE_DIR); if (existsSync(profiles))
-    for (const entry of readdirSync(profiles, { withFileTypes: true }))
-        if (entry.isDirectory() && PROFILE_ID_SHAPE.test(entry.name))
-            out.push(join(profiles, entry.name, 'profile.json'), join(profiles, entry.name, CONFIG_FILE), join(profiles, entry.name, STATE_FILE)); return out; }
-function providerLegacyPaths(agentDir) { return [join(agentDir, 'anthropic-subscriptions.json'), join(agentDir, 'openai-codex-subscriptions.json'), join(agentDir, 'provider-rotation.json')]; }
 function withLegacyProjectStateLock(root, run) {
     const path = join(root, STATE_FILE);
     const release = lockfile.lockSync(path, { realpath: false, retries: 0, stale: 30_000, update: 10_000 });
@@ -36,17 +29,7 @@ function withLegacyProjectStateLock(root, run) {
         release();
     }
 }
-export function initializeFreshScopedStore(input) {
-    const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
-    if (scopedStoreExists(store))
-        return;
-    const legacy = input.kind === 'user' ? userLegacyPaths(store.root) : input.kind === 'project' ? [join(store.root, STATE_FILE)] : providerLegacyPaths(store.root);
-    const legacyPath = legacy.find(existsSync);
-    if (legacyPath !== undefined)
-        throw new Error(`legacy scoped state exists at ${legacyPath}; crtr was updated and \`crtr sys daemon restart\` converts local state`);
-    createScopedStore(store, (db) => { createScopedSchema(db, input.kind); if (input.kind !== 'provider')
-        writeOwnerRoot(db, input.kind === 'user' ? 'user' : 'project', store.root); });
-}
+export { initializeFreshScopedStore } from './db.js';
 /** Conversion is intentionally explicit. Deployment coordination must prove all legacy writers at these shared roots are stopped before calling it. */
 export function convertLegacyScopedStore(input) {
     const store = input.kind === 'user' ? userStore(input.root) : input.kind === 'project' ? projectStore(input.root) : providerStore(input.root);
@@ -54,7 +37,7 @@ export function convertLegacyScopedStore(input) {
         return;
     if (input.kind === 'provider')
         throw new Error('provider conversion requires convertLegacyProviderStore() under coordinated shared-agent-dir activation');
-    const paths = input.kind === 'user' ? userLegacyPaths(store.root) : [join(store.root, STATE_FILE)];
+    const paths = legacyScopedStorePaths(store);
     const convert = () => {
         if (scopedStoreExists(store))
             return;
@@ -127,7 +110,7 @@ export async function convertLegacyProviderStore(agentDir) {
     const store = providerStore(agentDir);
     if (scopedStoreExists(store))
         return;
-    const paths = providerLegacyPaths(store.root);
+    const paths = legacyScopedStorePaths(store);
     await withLegacyProviderLocks(paths, async () => {
         if (scopedStoreExists(store))
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.313",
+  "version": "0.3.314",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.313",
+  "version": "0.3.314",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.313",
+      "version": "0.3.314",
       "hasInstallScript": true,
       "license": "MIT",
       "workspaces": [
@@ -5206,17 +5206,17 @@
     },
     "packages/crouter-api": {
       "name": "@north-light/crouter-api",
-      "version": "0.3.313",
+      "version": "0.3.314",
       "license": "UNLICENSED"
     },
     "packages/crouter-env-docker": {
       "name": "@north-light/crouter-env-docker",
-      "version": "0.3.313",
+      "version": "0.3.314",
       "license": "UNLICENSED"
     },
     "packages/crouter-sdk": {
       "name": "@north-light/crouter-sdk",
-      "version": "0.3.313",
+      "version": "0.3.314",
       "license": "UNLICENSED",
       "dependencies": {
         "@north-light/crouter-api": "^0.3.295"