@letta-ai/dreams 0.0.3 → 0.0.4

package/dist/sync.js

@@ -1,8 +1,13 @@
 "use strict";
 /**
- * Hook-safe `dreams sync` ([LET-10237] / [LET-10240]).
+ * Hook-safe `dreams sync` / `dreams wake` ([LET-10237] / [LET-10240]).
+ *
+ * - `dreams sync` (Stop / live turn): records a durable trigger (optional
+ *   session_id from stdin) and may spawn a detached worker.
+ * - `dreams wake` (SessionStart): quiet housekeeping (managed CLI + skill
+ *   repair) then force-kicks the worker for pending/backfill drain — no stdin
+ *   session hint.
  *
- * Default invocation records a durable trigger and may spawn a detached worker.
  * The hook parent always exits 0. The worker performs live scan + live-first
  * upload, then — only when an active backfill policy already exists and upload
  * budget remains — one backfill continuation slice + remaining-budget upload.
@@ -51,6 +56,7 @@ exports.commandSyncPause = commandSyncPause;
 exports.commandSyncResume = commandSyncResume;
 exports.commandSyncStatus = commandSyncStatus;
 exports.commandSyncWorker = commandSyncWorker;
+exports.commandWake = commandWake;
 exports.commandSync = commandSync;
 const node_child_process_1 = require("node:child_process");
 const path = __importStar(require("node:path"));
@@ -61,17 +67,15 @@ const leases_1 = require("./local/leases");
 const scan_1 = require("./local/scan");
 const state_lock_1 = require("./local/state-lock");
 const sync_control_1 = require("./local/sync-control");
+const codex_1 = require("./local/codex");
 const source_adapters_1 = require("./local/source-adapters");
+const managed_install_1 = require("./managed-install");
+const skill_1 = require("./skill");
 const store_1 = require("./store");
 const STDIN_LIMIT_BYTES = 64 * 1024;
 /** Resolve `--source <type>` at the sync command boundary (stdin never selects source). */
 function resolveSyncAdapter(sourceType) {
-    if (sourceType === undefined)
-        return (0, source_adapters_1.defaultSourceAdapter)();
-    const trimmed = sourceType.trim();
-    if (!trimmed)
-        throw new Error("unknown source type: (empty)");
-    return (0, source_adapters_1.getSourceAdapterByType)(trimmed);
+    return (0, source_adapters_1.resolveSourceAdapter)(sourceType);
 }
 function defaultWorkerEntry() {
     const candidate = process.argv[1] ? path.resolve(process.argv[1]) : "";
@@ -215,7 +219,7 @@ async function commandSyncSchedule(options) {
     const adapter = options.adapter;
     const sourceId = adapter.sourceId;
     try {
-        const sessionHint = await readSessionHintFromStdin(adapter);
+        const sessionHint = options.skipStdin ? null : await readSessionHintFromStdin(adapter);
         const { db } = openInstallationDb();
         try {
             const leaseRow = db.prepare("SELECT owner, expires_at FROM leases WHERE name = ?").get(leases_1.SYNC_WORKER_LEASE);
@@ -333,28 +337,78 @@ async function commandSyncResume(json) {
         (0, db_1.closeDb)();
     }
 }
-function commandSyncStatus(json) {
+function commandSyncStatus(json, sourceType) {
+    let adapter;
+    try {
+        adapter = resolveSyncAdapter(sourceType);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (json) {
+            console.log(JSON.stringify({ status: "error", schema_version: 1, code: "invalid_argument", message }));
+        }
+        else {
+            process.stderr.write(`${message}\n`);
+        }
+        return 1;
+    }
+    const harnessPresent = adapter.detect().present;
     const { db } = openInstallationDb();
     try {
+        const configured = (0, sync_control_1.sourceExists)(db, adapter.sourceId);
         const leaseRow = db.prepare("SELECT expires_at FROM leases WHERE name = ?").get(leases_1.SYNC_WORKER_LEASE);
-        const workerActive = Boolean(leaseRow && leaseRow.expires_at > Date.now());
-        (0, sync_control_1.normalizeStaleRunning)(db, workerActive);
-        const runtime = (0, sync_control_1.readRuntime)(db);
-        const trigger = (0, sync_control_1.observeTrigger)(db);
-        const pending = trigger.requested_gen > trigger.processed_gen || trigger.forced;
-        const effective = (0, sync_control_1.effectiveSyncState)({
-            runtime,
-            pending,
-            forced: trigger.forced,
-            workerActive,
-        });
+        const workerLeaseHeld = Boolean(leaseRow && leaseRow.expires_at > Date.now());
+        (0, sync_control_1.normalizeStaleRunning)(db, workerLeaseHeld);
+        // Peek only — status must not mint source/trigger rows for unconfigured adapters.
+        const runtime = (0, sync_control_1.peekRuntime)(db, adapter.sourceId);
+        const trigger = (0, sync_control_1.observeTrigger)(db, adapter.sourceId);
+        const pending = configured && (trigger.requested_gen > trigger.processed_gen || trigger.forced);
+        const workerActiveForSource = workerLeaseHeld && configured && (0, sync_control_1.readActiveSourceId)(db) === adapter.sourceId;
+        const effective = configured
+            ? (0, sync_control_1.effectiveSyncState)({
+                runtime,
+                pending,
+                forced: trigger.forced,
+                workerActive: workerActiveForSource,
+            })
+            : runtime.paused
+                ? "paused"
+                : "idle";
+        const discovery = adapter.sourceType === codex_1.CODEX_SOURCE_TYPE
+            ? (() => {
+                const report = (0, codex_1.inspectCodexDiscovery)();
+                return {
+                    status: report.status === "warning" ? "warning" : report.status === "ok" ? "ok" : report.status,
+                    harness_present: report.harness_present,
+                    sessions_dir_present: report.sessions_dir_present,
+                    candidates: report.candidates,
+                    supported: report.supported,
+                    unsupported: report.unsupported,
+                    excluded_subagent: report.excluded_subagent,
+                    by_reason: report.by_reason,
+                    examples: report.examples,
+                    message: report.message,
+                };
+            })()
+            : {
+                status: harnessPresent ? "ok" : "absent",
+                harness_present: harnessPresent,
+                message: harnessPresent ? null : `${adapter.displayName} was not detected`,
+            };
         const payload = {
             schema_version: 1,
             status: "ok",
+            source: adapter.sourceType,
+            source_id: adapter.sourceId,
+            source_configured: configured,
+            source_present: harnessPresent,
             sync: {
                 ...runtime,
                 effective_state: effective,
-                worker_active: workerActive,
+                worker_active: workerActiveForSource,
+                worker_lease_held: workerLeaseHeld,
+                // Stale ownership must not outlive the lease (belt-and-suspenders with completeSyncPass).
+                active_source_id: workerLeaseHeld ? (0, sync_control_1.readActiveSourceId)(db) : null,
                 pending,
                 requested_gen: trigger.requested_gen,
                 processed_gen: trigger.processed_gen,
@@ -362,19 +416,24 @@ function commandSyncStatus(json) {
                 session_hints: trigger.session_hints,
                 cadence_ms: sync_control_1.CADENCE_MS,
             },
+            discovery,
         };
         emit(json, payload, () => [
             "Dreams sync status",
             "",
+            `  Source:      ${adapter.sourceType} (${adapter.sourceId})${configured ? "" : " — not configured"}`,
             `  Effective:   ${effective}`,
             `  Runtime:     ${runtime.state}`,
             `  Paused:      ${runtime.paused ? "yes" : "no"}`,
             `  Pending:     ${pending ? "yes" : "no"}`,
-            `  Worker:      ${workerActive ? "active" : "idle"}`,
+            `  Worker:      ${workerActiveForSource ? "active for this source" : workerLeaseHeld ? "active for another source" : "idle"}`,
             `  Next due:    ${runtime.next_due_at ?? "(immediately)"}`,
             `  Last success:${runtime.last_success_at ? ` ${runtime.last_success_at}` : " (none)"}`,
             `  Last error:  ${runtime.last_error_code ? `${runtime.last_error_code}: ${runtime.last_error_message}` : " (none)"}`,
-        ].join("\n"));
+            discovery.message ? `  Discovery:   ${discovery.message}` : "",
+        ]
+            .filter((line) => line !== "")
+            .join("\n"));
         return 0;
     }
     finally {
@@ -594,7 +653,7 @@ async function commandSyncWorker(options) {
                 console.log(JSON.stringify({ status: "paused", schema_version: 1, source: adapter.sourceType }));
             return 0;
         }
-        (0, sync_control_1.markRuntimeRunning)(db);
+        (0, sync_control_1.markRuntimeRunning)(db, sourceId);
         while (passes < sync_control_1.MAX_TRAILING_PASSES) {
             if ((0, sync_control_1.isPaused)(db))
                 break;
@@ -704,8 +763,16 @@ async function commandSyncWorker(options) {
         catch {
             // test hooks must not break cleanup
         }
-        if (workerOwner)
+        if (workerOwner) {
             (0, leases_1.releaseLease)(db, leases_1.SYNC_WORKER_LEASE, workerOwner);
+            try {
+                // Ownership spans trailing passes; clear only when this worker exits.
+                (0, sync_control_1.clearActiveSourceId)(db);
+            }
+            catch {
+                // best effort
+            }
+        }
         (0, db_1.closeDb)();
         // Release the local-state lock before the final pending check so a hook that
         // spawned during shutdown cannot observe busy-on-lock and exit while we also
@@ -734,6 +801,103 @@ async function commandSyncWorker(options) {
             spawnDetachedWorker(true, successorType);
     }
 }
+/**
+ * SessionStart entrypoint: repair local CLI/skill quietly, then force-schedule
+ * the sync worker for pending live/backfill drain (no session stdin hint).
+ * Always exits 0 so harness hooks stay non-blocking.
+ */
+async function commandWake(options) {
+    let adapter;
+    try {
+        adapter = resolveSyncAdapter(options.sourceType);
+    }
+    catch (error) {
+        // Still exit 0 for hook safety; surface the error in JSON/human when possible.
+        const message = error instanceof Error ? error.message : String(error);
+        try {
+            emit(options.json, { status: "coalesced", schema_version: 1, command: "wake", worker: "schedule_error", message }, () => `Wake could not resolve source: ${message}`);
+        }
+        catch {
+            // ignore
+        }
+        return 0;
+    }
+    const housekeeping = { managed_install: null, skill: null, error: null };
+    try {
+        const managed = (0, managed_install_1.ensureManagedInstall)();
+        housekeeping.managed_install = managed.status;
+        housekeeping.skill = (0, skill_1.installSkill)();
+    }
+    catch (error) {
+        housekeeping.error = error instanceof Error ? error.message : String(error);
+    }
+    // Reuse the sync scheduler with force + no stdin. Emit a wake-shaped envelope
+    // by wrapping schedule output when JSON is requested.
+    if (!options.json) {
+        return commandSyncSchedule({ json: false, force: true, adapter, skipStdin: true });
+    }
+    // Capture schedule JSON by temporarily patching console.log is brittle; call
+    // the schedule path with json:true — it already prints. Prepend housekeeping
+    // by running schedule logic inline via a thin re-emit is hard. Instead: run
+    // schedule with json false internals... Simplest: run schedule with json true
+    // after printing nothing, and document housekeeping in a second object — agents
+    // prefer one object. So duplicate the force-schedule emit with housekeeping.
+    try {
+        const { db } = openInstallationDb();
+        try {
+            const leaseRow = db.prepare("SELECT owner, expires_at FROM leases WHERE name = ?").get(leases_1.SYNC_WORKER_LEASE);
+            const workerActive = Boolean(leaseRow && leaseRow.expires_at > Date.now());
+            (0, sync_control_1.normalizeStaleRunning)(db, workerActive);
+            const recorded = (0, sync_control_1.recordSyncRequest)(db, { forced: true, sessionHint: null, sourceId: adapter.sourceId });
+            if (recorded.paused) {
+                emit(true, { status: "paused", schema_version: 1, command: "wake", source: adapter.sourceType, housekeeping }, () => "Wake: sync paused.");
+                return 0;
+            }
+            if (workerActive) {
+                emit(true, {
+                    status: "coalesced",
+                    schema_version: 1,
+                    command: "wake",
+                    source: adapter.sourceType,
+                    trigger_generation: recorded.generation,
+                    forced: true,
+                    housekeeping,
+                }, () => "Wake coalesced into running worker.");
+                return 0;
+            }
+            const spawned = spawnDetachedWorker(true, adapter.sourceType);
+            if (!spawned) {
+                (0, sync_control_1.markRuntimeDegraded)(db, "spawn_failed", "worker could not be detached; trigger left pending for next wake", null, adapter.sourceId);
+            }
+            emit(true, {
+                status: spawned ? "scheduled" : "coalesced",
+                schema_version: 1,
+                command: "wake",
+                source: adapter.sourceType,
+                trigger_generation: recorded.generation,
+                forced: true,
+                worker: spawned ? "spawned" : "spawn_failed",
+                housekeeping,
+            }, () => (spawned ? "Wake scheduled sync worker." : "Wake recorded; worker spawn failed."));
+            return 0;
+        }
+        finally {
+            (0, db_1.closeDb)();
+        }
+    }
+    catch (error) {
+        emit(true, {
+            status: "coalesced",
+            schema_version: 1,
+            command: "wake",
+            source: adapter.sourceType,
+            worker: "schedule_error",
+            message: error instanceof Error ? error.message : String(error),
+            housekeeping,
+        }, () => "Wake could not fully schedule; will retry later.");
+        return 0;
+    }
+}
 async function commandSync(subcommand, options) {
     let adapter;
     try {
@@ -778,11 +942,7 @@ async function commandSync(subcommand, options) {
                 process.stderr.write(`--force is not valid with sync status\n`);
                 return 1;
             }
-            if (options.sourceType) {
-                process.stderr.write(`--source is not valid with sync status\n`);
-                return 1;
-            }
-            return commandSyncStatus(options.json);
+            return commandSyncStatus(options.json, options.sourceType);
         default:
             process.stderr.write(`Unknown sync subcommand: ${subcommand} — expected pause, resume, or status\n`);
             return 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/dreams",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "private": false,
   "description": "Dreams CLI - shared organizational memory from coding-agent transcripts",
   "license": "Apache-2.0",