trajectories 0.1.2 → 0.1.4

package/legacy/src/shared.ts

@@ -0,0 +1,221 @@
+import { closeSync, constants, existsSync, fstatSync, openSync, readFileSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { resolveCanonicalDbPath } from './canonical.js';
+import { ensurePrivateDirectory } from './private-storage.js';
+import { acquireWriterLease, isMemoryStorePath } from './writer-lease.js';
+import { TrajectoryReader } from './reader.js';
+import { TrajectoryDb } from './db.js';
+import { listSessions } from '../../src/log.js';
+import type { PageCursor } from '../../src/log-types.js';
+import { TrajectoriesError } from '../../src/log-types.js';
+import { exportManagedDelta } from '../../src/shared-managed.js';
+import { safeId } from '../../src/log-io.js';
+import { createSharedClient, createSharedHandler, sharedObservationId } from '../../src/shared.js';
+import type { ObservedState } from '../../src/shared.js';
+
+const help = `trajectories remote — cross-machine canonical history
+  remote serve --store <shared-directory> --token-file <0600-file>
+    [--host 127.0.0.1] [--port 8789]
+  remote push --url <endpoint> --token-file <0600-file> --machine <stable-id>
+    [--db <SQLite>] [--store <managed-store>] [--session <id>]
+  remote pull --url <endpoint> --token-file <0600-file> [--db <SQLite>]
+    [--store <managed-mirror>] [--machine <stable-origin-id>]
+  remote list --url <endpoint> --token-file <0600-file>
+Token path fallback: TRAJECTORIES_REMOTE_TOKEN_FILE. Tokens never belong in URLs.
+Push publishes observed canonical records; native files are not uploaded by this lane.
+--store additionally synchronizes managed logs and their referenced objects.
+Pull updates the existing SQLite lexical index; it never launches native harnesses.
+Pull --machine skips that originating machine's observed rows when a local shared:// copy is already stored.
+`;
+
+function required(value: string | undefined, option: string): string {
+  if (!value) throw new Error(`${option} is required.`);
+  return value;
+}
+
+/** Read an owner-only regular file through the validated descriptor. */
+function readToken(path: string): string {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.nlink !== 1 || (stat.mode & 0o777) !== 0o600 || (process.getuid && stat.uid !== process.getuid())) {
+      throw new Error('Remote token file must be an owner-owned regular file with mode 0600.');
+    }
+    if (stat.size > 4096) throw new Error('Remote token file is too large.');
+    const token = readFileSync(fd, 'utf8').trim();
+    if (!token || /[\s\x00-\x1f\x7f]/u.test(token)) throw new Error('Remote token file must contain one nonempty token.');
+    return token;
+  } finally { closeSync(fd); }
+}
+
+function project(state: ObservedState) {
+  const id = `shared:${state.id}`;
+  return {
+    session: { ...state.session, id, source_path: `shared://${state.machineId}/${encodeURIComponent(state.session.id)}`,
+      // The remote immutable head covers both record and metadata changes.
+      content_hash: state.head,
+      parent_session_id: state.session.parent_session_id
+        ? `shared:${sharedObservationId(state.machineId, state.session.parent_session_id)}` : null,
+    },
+    records: state.records.map(record => ({ ...record, id: `${id}:${record.id}`, session_id: id })),
+  };
+}
+
+function localSharedSession(dbPath: string, observationId: string) {
+  if (isMemoryStorePath(dbPath) || !existsSync(dbPath)) return null;
+  const reader = new TrajectoryReader(dbPath);
+  try {
+    const local = reader.getSession(`shared:${observationId}`);
+    return local?.source_path.startsWith('shared://') ? local : null;
+  } finally { reader.close(); }
+}
+
+export async function runSharedCli(argv: string[]): Promise<void> {
+  // Help must not open SQLite, managed stores, credentials or sockets.
+  if (!argv.length || argv.some(value => value === '--help' || value === '-h') || argv[0] === 'help') { console.log(help); return; }
+  const command = argv[0];
+  if (!['serve', 'push', 'pull', 'list'].includes(command!)) throw new Error('Expected remote serve, push, pull or list.');
+  const { values, positionals } = parseArgs({ args: argv.slice(1), strict: true, allowPositionals: true, options: {
+    store: { type: 'string' }, host: { type: 'string' }, port: { type: 'string' },
+    url: { type: 'string' }, 'token-file': { type: 'string' }, machine: { type: 'string' },
+    db: { type: 'string' }, session: { type: 'string' }, robot: { type: 'boolean' }, json: { type: 'boolean' },
+  }});
+  if (positionals.length) throw new Error('Unexpected remote positional arguments.');
+  const allowed: Record<string, Set<string>> = {
+    serve: new Set(['store', 'host', 'port', 'token-file', 'json', 'robot']),
+    push: new Set(['url', 'token-file', 'machine', 'db', 'store', 'session', 'json', 'robot']),
+    pull: new Set(['url', 'token-file', 'db', 'store', 'machine', 'json', 'robot']),
+    list: new Set(['url', 'token-file', 'json', 'robot']),
+  };
+  for (const option of Object.keys(values)) {
+    if (!allowed[command!]!.has(option)) throw new Error(`--${option} is not supported by remote ${command}.`);
+  }
+  const machine = values.machine === undefined ? undefined : safeId(values.machine);
+  const port = values.port === undefined ? 8789 : Number(values.port);
+  if (command === 'serve' && (!Number.isInteger(port) || port < 0 || port > 65535)) throw new Error('--port must be an integer from 0 through 65535.');
+  const token = readToken(required(values['token-file'] ?? process.env.TRAJECTORIES_REMOTE_TOKEN_FILE, '--token-file'));
+  const emit = (value: unknown) => console.log(JSON.stringify(value));
+  if (command === 'serve') {
+    const store = resolve(required(values.store, '--store'));
+    const server = Bun.serve({ hostname: values.host ?? '127.0.0.1', port,
+      maxRequestBodySize: 64 * 1024 * 1024, fetch: createSharedHandler({ store, token }),
+    });
+    const close = () => { server.stop(true); process.removeListener('SIGINT', close); process.removeListener('SIGTERM', close); };
+    process.on('SIGINT', close); process.on('SIGTERM', close);
+    emit({ command: 'serve', host: server.hostname, port: server.port });
+    return;
+  }
+  const client = createSharedClient({ url: required(values.url, '--url'), token });
+  if (command === 'list') {
+    const observed = await client.listObserved();
+    const managed = await client.listManaged();
+    emit({ observed: observed.map(item => ({ id: item.id, head: item.head, machineId: item.machineId,
+      source: item.session.source, records: item.session.record_count })),
+      managed: managed.map(item => ({ id: item.id, head: item.head })),
+    });
+    return;
+  }
+  const dbPath = values.db ?? resolveCanonicalDbPath();
+  if (command === 'push') {
+    const machineId = required(machine, '--machine');
+    const observed = [];
+    let selected = false;
+    // An explicit managed store without --db selects only the managed lane.
+    if (!values.store || values.db) {
+      const reader = new TrajectoryReader(dbPath);
+      try {
+        const ids = values.session ? [values.session] : reader.getAllSessions().map(session => session.id);
+        for (const id of ids) {
+          const captured = reader.readSessionForSync(id);
+          if (!captured) continue;
+          const { session, records } = captured;
+          // Derived mirrors and managed projections cannot become native originals.
+          if (session.source === 'managed' || session.id.startsWith('managed:') || session.source_path.startsWith('shared://')) continue;
+          selected = true;
+          const diagnostics = captured.diagnostics.map(item => ({ code: item.code,
+            occurrenceCount: item.occurrence_count, sample: item.sample, firstSeenAt: item.first_seen_at }));
+          observed.push(await client.pushObserved({ machineId, session: { ...session, diagnostics }, records }));
+        }
+      } finally { reader.close(); }
+    }
+    const managed = [];
+    if (values.store) {
+      const store = resolve(values.store);
+      let cursor: PageCursor | undefined;
+      do {
+        const page = await listSessions(store, { cursor, limit: 1000 });
+        for (const session of page.items) {
+          if (values.session && session.id !== values.session) continue;
+          selected = true;
+          managed.push(await client.pushManaged(store, session.id));
+        }
+        cursor = page.nextCursor ?? undefined;
+      } while (cursor);
+    }
+    if (values.session && !selected) throw new Error('Selected original session was not found; managed projections require --store.');
+    emit({ command, observed, managed });
+    return;
+  }
+  if (!isMemoryStorePath(dbPath)) {
+    if (!values.db && !process.env.TRAJECTORIES_DB && !process.env.LEDGER_DB) ensurePrivateDirectory(dirname(dbPath));
+    else await mkdir(dirname(dbPath), { recursive: true, mode: 0o700 });
+  }
+  const observed = [];
+  for (const item of await client.listObserved()) {
+    const local = localSharedSession(dbPath, item.id);
+    if (item.machineId === machine && local) {
+      observed.push({ id: item.id, head: item.head, outcome: 'skipped-origin' });
+      continue;
+    }
+    if (local && local.content_hash === item.head) {
+      observed.push({ id: item.id, head: item.head, records: local.record_count, outcome: 'unchanged' });
+      continue;
+    }
+    const state = await client.getObserved(item.id);
+    const lease = isMemoryStorePath(dbPath) ? null : acquireWriterLease(dbPath, { holder: 'trajectories remote pull' });
+    try {
+      const db = new TrajectoryDb(dbPath);
+      try {
+        const projection = project(state);
+        if (db.getTombstone(projection.session.id)) { observed.push({ id: item.id, head: state.head, outcome: 'deleted' }); continue; }
+        const saved = db.saveSession(projection.session, projection.records, state.session.diagnostics);
+        observed.push({ id: item.id, head: state.head, records: projection.records.length,
+          outcome: saved.inserted ? 'inserted' : saved.updated ? 'updated' : 'unchanged' });
+      } finally { db.close(); }
+    } finally { lease?.close(); }
+  }
+  const managed = [];
+  let conflicts = 0;
+  if (values.store) {
+    const store = resolve(values.store);
+    for (const session of await client.listManaged()) {
+      try { managed.push({ ...await client.pullManaged(store, session.id), outcome: 'pulled' }); }
+      catch (error) {
+        if (!(error instanceof TrajectoriesError) || !['STALE_HEAD', 'INTENT_CONFLICT'].includes(error.code)) throw error;
+        // The failed pull may have observed a newer branch than the original list.
+        const remote = (await client.listManaged()).find(item => item.id === session.id);
+        let ahead;
+        try { if (remote) ahead = await exportManagedDelta(store, session.id, { afterHead: remote.head }); }
+        catch (proofError) {
+          if (!(proofError instanceof TrajectoriesError) || !['STALE_HEAD', 'NOT_FOUND'].includes(proofError.code)) throw proofError;
+        }
+        if (remote && ahead?.frames.length && ahead.head !== remote.head) {
+          managed.push({ id: session.id, head: ahead.head, remoteHead: remote.head, outcome: 'ahead' });
+        } else {
+          conflicts++;
+          managed.push({ id: session.id, remoteHead: remote?.head, outcome: 'conflict', code: error.code });
+        }
+      }
+    }
+    // Existing indexer preserves accepted managed ordering, FTS and tombstones.
+    // Its summary is emitted separately and contains no record bodies.
+    if (managed.length) {
+      const { runManagedCli } = await import('./managed.js');
+      await runManagedCli('index', ['--store', resolve(values.store), '--db', dbPath, '--robot']);
+    }
+  }
+  emit({ command, observed, managed });
+  if (conflicts) throw new TrajectoriesError('STALE_HEAD', `${conflicts} managed session(s) conflict; other histories were pulled and indexed. Local branches were preserved.`);
+}

package/package.json

@@ -1,13 +1,35 @@
 {
   "name": "trajectories",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Portable coding-agent sessions: read, search, convert, and continue across harnesses.",
   "type": "module",
   "license": "Apache-2.0",
-  "engines": { "node": ">=22.13.0", "bun": ">=1.4.2" },
-  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
-  "bin": { "trajectories": "./dist/cli.js" },
-  "files": ["dist", "docs", "legacy/src", "legacy/bin", "legacy/scripts", "legacy/NOTICE.md", "ops", "skills", "README.md", "CHANGELOG.md", "LICENSE"],
+  "engines": {
+    "node": ">=22.13.0",
+    "bun": ">=1.4.2"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "trajectories": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "legacy/src",
+    "legacy/bin",
+    "legacy/scripts",
+    "legacy/NOTICE.md",
+    "ops",
+    "skills",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json && bun build src/index.ts --target node --format esm --outfile dist/index.js && bun build src/normalization-runtime.ts --target bun --format esm --outfile dist/normalization-runtime.js && bun build src/cli.ts --target bun --format esm --external onnxruntime-node --define TRAJECTORIES_BUNDLED_CLI=true --outfile dist/cli.js && bun scripts/build-assets.ts",
     "build:native": "bun run build && bun scripts/build-native.ts",
@@ -16,9 +38,24 @@
     "test:native": "bun scripts/check-native.ts",
     "test:package": "bun run build && bun test ./smoke/package.test.ts && bun run test:native"
   },
-  "dependencies": { "@letta-ai/trajectory": "0.4.3" },
-  "optionalDependencies": { "onnxruntime-node": "^1.29.0" },
-  "devDependencies": { "@types/node": "^22.20.1", "@types/bun": "1.3.14", "typescript": "^5.9.3" },
-  "repository": { "type": "git", "url": "git+https://github.com/archeism/oh-my-ai.git", "directory": "packages/trajectories" },
-  "publishConfig": { "access": "public" }
+  "dependencies": {
+    "@letta-ai/trajectory": "0.4.3"
+  },
+  "optionalDependencies": {
+    "onnxruntime-node": "^1.29.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "@types/bun": "1.3.14",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/archeism/oh-my-ai.git",
+    "directory": "packages/trajectories"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "7cd6e650f748e57ef14c50b5d9067ebc52da8155"
 }