@pellux/goodvibes-sdk 0.21.18 → 0.21.21

package/dist/_internal/platform/tools/state/index.js

@@ -51,6 +51,9 @@ export function createStateTool(kvState, projectIndex, options) {
     const hookDispatcher = options.hookDispatcher;
     const modeManager = options.modeManager;
     const telemetryDB = options.telemetryDB;
+    const workingDir = options.workingDir;
+    const daemonHomeDir = options.daemonHomeDir;
+    const swapManager = options.swapManager;
     // Session start time and telemetry are scoped per-instance so multiple
     // createStateTool() calls don't share state.
     const SESSION_START_MS = Date.now();
@@ -82,8 +85,8 @@ export function createStateTool(kvState, projectIndex, options) {
             const input = args;
             const { mode } = input;
             switch (mode) {
-                case 'get': return runGet(input, kvState);
-                case 'set': return runSet(input, kvState);
+                case 'get': return runGet(input, kvState, workingDir, daemonHomeDir);
+                case 'set': return runSet(input, kvState, workingDir, daemonHomeDir, swapManager);
                 case 'list': return runList(input, kvState);
                 case 'clear': return runClear(input, kvState);
                 case 'budget': return runBudget(kvState, projectIndex);
@@ -404,19 +407,60 @@ function runMode(input, manager) {
     }
     return { success: false, error: `Unknown mode action: ${String(action)}` };
 }
-async function runGet(input, kvState) {
+/**
+ * Well-known read-only keys surfaced directly by the state tool.
+ * These keys are injected into the `get` response alongside KVState values
+ * and rejected with an error in `set` to prevent mutation.
+ */
+const WELL_KNOWN_READONLY_KEYS = new Set(['runtime.workingDir', 'daemon.homeDir']);
+async function runGet(input, kvState, workingDir, daemonHomeDir) {
     const keys = input.keys ?? [];
     if (keys.length === 0) {
         return { success: false, error: 'mode "get" requires a non-empty "keys" array' };
     }
-    const values = await kvState.get(keys);
+    // Separate well-known keys from regular KV keys
+    const kvKeys = keys.filter((k) => !WELL_KNOWN_READONLY_KEYS.has(k));
+    const values = kvKeys.length > 0 ? await kvState.get(kvKeys) : {};
+    // Inject well-known read-only keys
+    if (keys.includes('runtime.workingDir')) {
+        values['runtime.workingDir'] = workingDir ?? null;
+    }
+    if (keys.includes('daemon.homeDir')) {
+        values['daemon.homeDir'] = daemonHomeDir ?? null;
+    }
     return { success: true, output: JSON.stringify({ mode: 'get', values }) };
 }
-async function runSet(input, kvState) {
+async function runSet(input, kvState, _workingDir, _daemonHomeDir, swapManager) {
     const values = input.values;
     if (!values || typeof values !== 'object') {
         return { success: false, error: 'mode "set" requires a "values" object' };
     }
+    // Handle runtime.workingDir specially — delegate to swap manager if available.
+    if ('runtime.workingDir' in values) {
+        const newDir = values['runtime.workingDir'];
+        if (typeof newDir !== 'string' || !newDir.trim()) {
+            return { success: false, error: 'runtime.workingDir must be a non-empty string.' };
+        }
+        if (!swapManager) {
+            return {
+                success: false,
+                error: 'Cannot write to runtime.workingDir: no swap manager available. Use POST /config to change runtime.workingDir.',
+            };
+        }
+        const result = await swapManager.requestSwap(newDir);
+        if (!result.ok) {
+            return { success: false, error: `Workspace swap failed (${result.code ?? 'UNKNOWN'}): ${result.reason ?? 'unknown error'}` };
+        }
+        return { success: true, output: JSON.stringify({ mode: 'set', swapped: true, newWorkingDir: newDir }) };
+    }
+    // Reject writes to other read-only well-known keys
+    const readonlyAttempts = Object.keys(values).filter((k) => WELL_KNOWN_READONLY_KEYS.has(k));
+    if (readonlyAttempts.length > 0) {
+        return {
+            success: false,
+            error: `Cannot write to read-only well-known key(s): ${readonlyAttempts.join(', ')}. These keys are immutable at runtime.`,
+        };
+    }
     await kvState.set(values);
     // Only report keys that KVState actually persists (exclude reserved keys).
     const written = Object.keys(values).filter((k) => !RESERVED_KEYS.has(k));

package/dist/_internal/platform/version.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-let version = '0.21.18';
+let version = '0.21.21';
 try {
     const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', '..', 'package.json'), 'utf-8'));
     version = pkg.version ?? version;

package/dist/_internal/platform/workspace/daemon-home.d.ts

@@ -0,0 +1,70 @@
+/**
+ * daemon-home.ts
+ *
+ * Resolves and manages the daemon's identity home directory (`daemon.homeDir`).
+ *
+ * The daemon home holds immutable-after-startup identity state:
+ *   - auth-users.json
+ *   - auth-bootstrap.txt
+ *   - daemon-settings.json
+ *   - operator-tokens.json
+ *
+ * Resolution order (first match wins):
+ *   1. --daemon-home=<path> CLI arg (passed as daemonHomeArg)
+ *   2. GOODVIBES_DAEMON_HOME environment variable
+ *   3. ~/.goodvibes/daemon/
+ *
+ * One-time migration (run on first 0.21.19+ startup):
+ *   - If ~/.goodvibes/daemon/ does not exist:
+ *     - ~/.goodvibes/tui/auth-users.json → ~/.goodvibes/daemon/auth-users.json
+ *     - ~/.goodvibes/tui/auth-bootstrap.txt → ~/.goodvibes/daemon/auth-bootstrap.txt
+ *     - <cwd>/.goodvibes/operator-tokens.json → ~/.goodvibes/daemon/operator-tokens.json (F3 revision)
+ *   - Old paths are left intact (never deleted) to avoid breaking older binaries.
+ */
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+export interface DaemonHomeDirs {
+    /** Absolute path to the daemon home directory (immutable identity state). */
+    readonly daemonHomeDir: string;
+    /** True if this is the first startup at this daemon home (migration was run). */
+    readonly freshInstall: boolean;
+}
+export interface DaemonHomeOptions {
+    /** Value of --daemon-home CLI flag, if provided. */
+    readonly daemonHomeArg?: string | undefined;
+    /** Current working directory, used as base for operator-tokens migration. */
+    readonly cwd?: string;
+    /** Override process.env for testing. */
+    readonly env?: NodeJS.ProcessEnv;
+}
+/**
+ * Optional dependencies for migration event emission.
+ * When provided, migration outcomes are broadcast on the runtime event bus
+ * under the 'workspace' domain.
+ */
+export interface DaemonHomeMigrationDeps {
+    readonly runtimeBus?: RuntimeEventBus;
+}
+/**
+ * Resolve the daemon home directory from CLI flag, environment variable, or default.
+ */
+export declare function resolveDaemonHomeDir(options?: DaemonHomeOptions): string;
+/**
+ * Run migration if the daemon home directory does not yet exist.
+ * Creates the directory and copies identity files from legacy paths if found.
+ * Old files are NOT deleted.
+ *
+ * Returns `freshInstall: true` when migration ran, `false` when the dir already existed.
+ */
+export declare function runDaemonHomeMigration(daemonHomeDir: string, options?: DaemonHomeOptions, deps?: DaemonHomeMigrationDeps): DaemonHomeDirs;
+/**
+ * Read a single key from daemon-settings.json, or return undefined if missing.
+ */
+export declare function readDaemonSetting(daemonHomeDir: string, key: string): string | undefined;
+/**
+ * Write a single key into daemon-settings.json (merge, not replace).
+ *
+ * Uses a write-to-tmp-then-rename pattern for atomicity:
+ * a crash between write and rename leaves a .tmp file, never a corrupt target.
+ */
+export declare function writeDaemonSetting(daemonHomeDir: string, key: string, value: string): void;
+//# sourceMappingURL=daemon-home.d.ts.map

package/dist/_internal/platform/workspace/daemon-home.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-home.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/workspace/daemon-home.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAOH,OAAO,KAAK,EAAE,eAAe,EAAwB,MAAM,4BAA4B,CAAC;AAOxF,MAAM,WAAW,cAAc;IAC7B,6EAA6E;IAC7E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,iFAAiF;IACjF,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,iBAAiB;IAChC,oDAAoD;IACpD,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5C,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,wCAAwC;IACxC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,CAAC,EAAE,eAAe,CAAC;CACvC;AAMD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAiB5E;AAMD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,iBAAsB,EAC/B,IAAI,GAAE,uBAA4B,GACjC,cAAc,CAoFhB;AAMD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAWxF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAc1F"}

package/dist/_internal/platform/workspace/daemon-home.js

@@ -0,0 +1,221 @@
+/**
+ * daemon-home.ts
+ *
+ * Resolves and manages the daemon's identity home directory (`daemon.homeDir`).
+ *
+ * The daemon home holds immutable-after-startup identity state:
+ *   - auth-users.json
+ *   - auth-bootstrap.txt
+ *   - daemon-settings.json
+ *   - operator-tokens.json
+ *
+ * Resolution order (first match wins):
+ *   1. --daemon-home=<path> CLI arg (passed as daemonHomeArg)
+ *   2. GOODVIBES_DAEMON_HOME environment variable
+ *   3. ~/.goodvibes/daemon/
+ *
+ * One-time migration (run on first 0.21.19+ startup):
+ *   - If ~/.goodvibes/daemon/ does not exist:
+ *     - ~/.goodvibes/tui/auth-users.json → ~/.goodvibes/daemon/auth-users.json
+ *     - ~/.goodvibes/tui/auth-bootstrap.txt → ~/.goodvibes/daemon/auth-bootstrap.txt
+ *     - <cwd>/.goodvibes/operator-tokens.json → ~/.goodvibes/daemon/operator-tokens.json (F3 revision)
+ *   - Old paths are left intact (never deleted) to avoid breaking older binaries.
+ */
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, renameSync, readdirSync } from 'node:fs';
+import { join, isAbsolute, resolve, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from '../utils/logger.js';
+import { createEventEnvelope } from '../runtime/events/index.js';
+// ---------------------------------------------------------------------------
+// Resolution
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the daemon home directory from CLI flag, environment variable, or default.
+ */
+export function resolveDaemonHomeDir(options = {}) {
+    const env = options.env ?? process.env;
+    // 1. CLI arg
+    if (options.daemonHomeArg) {
+        const p = options.daemonHomeArg.trim();
+        if (p)
+            return isAbsolute(p) ? resolve(p) : resolve(process.cwd(), p);
+    }
+    // 2. Env var
+    const envVal = env['GOODVIBES_DAEMON_HOME']?.trim();
+    if (envVal) {
+        return isAbsolute(envVal) ? resolve(envVal) : resolve(process.cwd(), envVal);
+    }
+    // 3. Default: ~/.goodvibes/daemon/
+    return join(homedir(), '.goodvibes', 'daemon');
+}
+// ---------------------------------------------------------------------------
+// One-time migration
+// ---------------------------------------------------------------------------
+/**
+ * Run migration if the daemon home directory does not yet exist.
+ * Creates the directory and copies identity files from legacy paths if found.
+ * Old files are NOT deleted.
+ *
+ * Returns `freshInstall: true` when migration ran, `false` when the dir already existed.
+ */
+export function runDaemonHomeMigration(daemonHomeDir, options = {}, deps = {}) {
+    const alreadyExists = existsSync(daemonHomeDir);
+    if (alreadyExists) {
+        return { daemonHomeDir, freshInstall: false };
+    }
+    // Create the daemon home directory tree
+    mkdirSync(daemonHomeDir, { recursive: true });
+    const userGoodVibesRoot = join(homedir(), '.goodvibes');
+    const cwd = options.cwd ?? process.cwd();
+    // Migrate auth-users.json from tui surface path
+    const legacyAuthUsers = join(userGoodVibesRoot, 'tui', 'auth-users.json');
+    if (existsSync(legacyAuthUsers)) {
+        safeCopy(legacyAuthUsers, join(daemonHomeDir, 'auth-users.json'));
+    }
+    // Migrate auth-bootstrap.txt from tui surface path
+    const legacyBootstrap = join(userGoodVibesRoot, 'tui', 'auth-bootstrap.txt');
+    if (existsSync(legacyBootstrap)) {
+        safeCopy(legacyBootstrap, join(daemonHomeDir, 'auth-bootstrap.txt'));
+    }
+    // Migrate operator-tokens.json — search multiple legacy paths (F3 revision).
+    // 0.21.17 used <cwd>/.goodvibes/operator-tokens.json (workspace-scoped).
+    // 0.21.16 and earlier used surface-scoped ~/.goodvibes/<surface>/companion-token.json.
+    // 0.21.19+ canonical path is <daemonHomeDir>/operator-tokens.json.
+    const destTokenPath = join(daemonHomeDir, 'operator-tokens.json');
+    if (!existsSync(destTokenPath)) {
+        // Priority 1: workspace-scoped path from 0.21.17
+        const legacyWorkspaceTokens = join(cwd, '.goodvibes', 'operator-tokens.json');
+        // Priority 2: surface-scoped legacy tokens from 0.21.16 and earlier
+        const legacySurfaceToken = join(userGoodVibesRoot, 'tui', 'companion-token.json');
+        // Priority 3: XDG data home if set
+        const xdgDataHome = options.env?.['XDG_DATA_HOME'];
+        const xdgToken = xdgDataHome ? join(xdgDataHome, 'goodvibes', 'operator-tokens.json') : null;
+        // Scan for any surface-scoped companion-token.json files under ~/.goodvibes/
+        const surfaceScopedTokens = [];
+        try {
+            const entries = readdirSync(userGoodVibesRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const candidate = join(userGoodVibesRoot, entry.name, 'companion-token.json');
+                    if (existsSync(candidate))
+                        surfaceScopedTokens.push(candidate);
+                }
+            }
+        }
+        catch {
+            // Best-effort scan
+        }
+        const tokenSources = [
+            legacyWorkspaceTokens,
+            ...(xdgToken ? [xdgToken] : []),
+            legacySurfaceToken,
+            ...surfaceScopedTokens,
+        ];
+        for (const src of tokenSources) {
+            if (!existsSync(src))
+                continue;
+            // Validate JSON before copying — corrupt JSON must not be migrated.
+            try {
+                JSON.parse(readFileSync(src, 'utf-8'));
+            }
+            catch (parseErr) {
+                const reason = parseErr instanceof Error ? parseErr.message : String(parseErr);
+                logger.warn('daemon-home: skipping corrupt token file during migration', {
+                    sourcePath: src,
+                    reason,
+                });
+                _emitMigrationEvent(deps.runtimeBus, { type: 'WORKSPACE_IDENTITY_MIGRATION_FAILED', sourcePath: src, reason });
+                safeCopy(src, destTokenPath, { skipIfInvalid: true });
+                continue;
+            }
+            if (safeCopy(src, destTokenPath)) {
+                logger.info('daemon-home: migrated operator token', { from: src, to: destTokenPath });
+                _emitMigrationEvent(deps.runtimeBus, { type: 'WORKSPACE_IDENTITY_MIGRATED', from: src, to: destTokenPath });
+            }
+            break; // First valid source wins
+        }
+    }
+    return { daemonHomeDir, freshInstall: true };
+}
+// ---------------------------------------------------------------------------
+// Daemon settings persistence
+// ---------------------------------------------------------------------------
+/**
+ * Read a single key from daemon-settings.json, or return undefined if missing.
+ */
+export function readDaemonSetting(daemonHomeDir, key) {
+    const settingsPath = join(daemonHomeDir, 'daemon-settings.json');
+    if (!existsSync(settingsPath))
+        return undefined;
+    try {
+        const raw = readFileSync(settingsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const val = parsed[key];
+        return typeof val === 'string' ? val : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write a single key into daemon-settings.json (merge, not replace).
+ *
+ * Uses a write-to-tmp-then-rename pattern for atomicity:
+ * a crash between write and rename leaves a .tmp file, never a corrupt target.
+ */
+export function writeDaemonSetting(daemonHomeDir, key, value) {
+    mkdirSync(daemonHomeDir, { recursive: true });
+    const settingsPath = join(daemonHomeDir, 'daemon-settings.json');
+    const tmpPath = settingsPath + '.tmp';
+    let existing = {};
+    if (existsSync(settingsPath)) {
+        try {
+            existing = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        }
+        catch {
+            // Overwrite corrupt file
+        }
+    }
+    writeFileSync(tmpPath, JSON.stringify({ ...existing, [key]: value }, null, 2), 'utf-8');
+    renameSync(tmpPath, settingsPath);
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Emit a workspace migration event on the runtime bus.
+ * Never throws — bus emission must not interrupt migration.
+ */
+function _emitMigrationEvent(bus, payload) {
+    if (!bus)
+        return;
+    try {
+        const envelope = createEventEnvelope(payload.type, payload, { sessionId: '', source: 'daemon-home-migration' });
+        bus.emit('workspace', 
+        // WorkspaceEvent discriminated-union member; single widening cast is safe.
+        envelope);
+    }
+    catch {
+        // Swallow — never let event emission break migration
+    }
+}
+/**
+ * Copy src to dest. Returns true on success, false on failure.
+ * Failures are logged at warn level. Never throws.
+ */
+function safeCopy(src, dest, opts) {
+    if (opts?.skipIfInvalid)
+        return false;
+    try {
+        copyFileSync(src, dest);
+        return true;
+    }
+    catch (err) {
+        logger.warn('daemon-home: safeCopy failed', {
+            src,
+            dest,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}

package/dist/_internal/platform/workspace/workspace-swap-manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * workspace-swap-manager.ts
+ *
+ * Manages mutable runtime.workingDir transitions.
+ *
+ * The working directory hosts all conversation-scoped state:
+ * sessions, memory, logs, artifacts, knowledge stores. It can be swapped
+ * at runtime via POST /config {key:"runtime.workingDir", value:"<path>"}.
+ *
+ * Swap policy:
+ *   - Refused with WORKSPACE_BUSY when any session has pendingInputCount > 0.
+ *   - Returns INVALID_PATH when the new path cannot be created.
+ *   - On success, persists the new path to <daemonHomeDir>/daemon-settings.json.
+ *
+ * Events emitted on runtimeBus (domain: 'workspace'):
+ *   WORKSPACE_SWAP_STARTED   — before swap begins
+ *   WORKSPACE_SWAP_REFUSED   — when swap is rejected
+ *   WORKSPACE_SWAP_COMPLETED — after all stores re-rooted
+ */
+import type { RuntimeEventBus } from '../runtime/events/index.js';
+export interface WorkspaceSwapDeps {
+    readonly runtimeBus: RuntimeEventBus | null;
+    readonly daemonHomeDir: string;
+    /**
+     * Called by the manager to check whether any session currently has pending
+     * input (i.e. `pendingInputCount > 0`). Returns the count of busy sessions.
+     */
+    readonly getBusySessionCount: () => number;
+    /**
+     * Called after the manager validates the new path.
+     * Implementations must close existing stores and re-open them at newWorkingDir.
+     * May throw; the manager catches and returns INVALID_PATH.
+     */
+    readonly rerootStores: (newWorkingDir: string) => Promise<void>;
+}
+export type WorkspaceSwapResult = {
+    ok: true;
+    previous: string;
+    current: string;
+} | {
+    ok: false;
+    code: 'WORKSPACE_BUSY';
+    reason: string;
+    retryAfter: number;
+} | {
+    ok: false;
+    code: 'INVALID_PATH';
+    reason: string;
+};
+export declare class WorkspaceSwapManager {
+    private readonly deps;
+    private currentWorkingDir;
+    private swapInProgress;
+    constructor(initialWorkingDir: string, deps: WorkspaceSwapDeps);
+    getCurrentWorkingDir(): string;
+    requestSwap(newWorkingDir: string): Promise<WorkspaceSwapResult>;
+    private _requestSwapInner;
+    private _emit;
+}
+//# sourceMappingURL=workspace-swap-manager.d.ts.map

package/dist/_internal/platform/workspace/workspace-swap-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-swap-manager.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/workspace/workspace-swap-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAOlE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,MAAM,CAAC;IAC3C;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACjE;AAMD,MAAM,MAAM,mBAAmB,GAC3B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACzE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAMxD,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,IAAI;IALvB,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,cAAc,CAA6C;gBAGjE,iBAAiB,EAAE,MAAM,EACR,IAAI,EAAE,iBAAiB;IAK1C,oBAAoB,IAAI,MAAM;IAIxB,WAAW,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;YAYxD,iBAAiB;IAgE/B,OAAO,CAAC,KAAK;CAmBd"}

package/dist/_internal/platform/workspace/workspace-swap-manager.js

@@ -0,0 +1,117 @@
+/**
+ * workspace-swap-manager.ts
+ *
+ * Manages mutable runtime.workingDir transitions.
+ *
+ * The working directory hosts all conversation-scoped state:
+ * sessions, memory, logs, artifacts, knowledge stores. It can be swapped
+ * at runtime via POST /config {key:"runtime.workingDir", value:"<path>"}.
+ *
+ * Swap policy:
+ *   - Refused with WORKSPACE_BUSY when any session has pendingInputCount > 0.
+ *   - Returns INVALID_PATH when the new path cannot be created.
+ *   - On success, persists the new path to <daemonHomeDir>/daemon-settings.json.
+ *
+ * Events emitted on runtimeBus (domain: 'workspace'):
+ *   WORKSPACE_SWAP_STARTED   — before swap begins
+ *   WORKSPACE_SWAP_REFUSED   — when swap is rejected
+ *   WORKSPACE_SWAP_COMPLETED — after all stores re-rooted
+ */
+import { mkdirSync, existsSync } from 'node:fs';
+import { isAbsolute, resolve, join } from 'node:path';
+import { writeDaemonSetting } from './daemon-home.js';
+import { createEventEnvelope } from '../runtime/events/index.js';
+// ---------------------------------------------------------------------------
+// WorkspaceSwapManager
+// ---------------------------------------------------------------------------
+export class WorkspaceSwapManager {
+    deps;
+    currentWorkingDir;
+    swapInProgress = null;
+    constructor(initialWorkingDir, deps) {
+        this.deps = deps;
+        this.currentWorkingDir = initialWorkingDir;
+    }
+    getCurrentWorkingDir() {
+        return this.currentWorkingDir;
+    }
+    async requestSwap(newWorkingDir) {
+        if (this.swapInProgress) {
+            return { ok: false, code: 'WORKSPACE_BUSY', reason: 'Another workspace swap is already in progress.', retryAfter: 1 };
+        }
+        this.swapInProgress = this._requestSwapInner(newWorkingDir);
+        try {
+            return await this.swapInProgress;
+        }
+        finally {
+            this.swapInProgress = null;
+        }
+    }
+    async _requestSwapInner(newWorkingDir) {
+        const raw = newWorkingDir.trim();
+        if (!raw) {
+            return { ok: false, code: 'INVALID_PATH', reason: 'Working directory path must not be empty.' };
+        }
+        const resolved = isAbsolute(raw) ? resolve(raw) : resolve(this.currentWorkingDir, raw);
+        const from = this.currentWorkingDir;
+        const to = resolved;
+        // Check busy sessions BEFORE emitting STARTED — don't emit STARTED if we'll immediately refuse.
+        const busyCount = this.deps.getBusySessionCount();
+        if (busyCount > 0) {
+            const reason = `${busyCount} session(s) have pending input. Retry after active inputs complete.`;
+            this._emit({ type: 'WORKSPACE_SWAP_REFUSED', from, to, reason, retryAfter: 5 });
+            return { ok: false, code: 'WORKSPACE_BUSY', reason, retryAfter: 5 };
+        }
+        // Swap is proceeding — emit STARTED now that busy check passed.
+        this._emit({ type: 'WORKSPACE_SWAP_STARTED', from, to });
+        // Validate and create directory
+        try {
+            mkdirSync(join(resolved, '.goodvibes', 'sessions'), { recursive: true });
+            mkdirSync(join(resolved, '.goodvibes', 'memory'), { recursive: true });
+            mkdirSync(join(resolved, '.goodvibes', 'logs'), { recursive: true });
+        }
+        catch (err) {
+            const reason = `Cannot create workspace directory at '${resolved}': ${err instanceof Error ? err.message : String(err)}`;
+            return { ok: false, code: 'INVALID_PATH', reason };
+        }
+        // Re-root all stores
+        try {
+            await this.deps.rerootStores(resolved);
+        }
+        catch (err) {
+            const reason = `Failed to re-initialize stores at '${resolved}': ${err instanceof Error ? err.message : String(err)}`;
+            return { ok: false, code: 'INVALID_PATH', reason };
+        }
+        // Update internal state
+        this.currentWorkingDir = resolved;
+        // Persist to daemon settings
+        let persistedInDaemonSettings = false;
+        try {
+            writeDaemonSetting(this.deps.daemonHomeDir, 'runtime.workingDir', resolved);
+            persistedInDaemonSettings = true;
+        }
+        catch {
+            // Non-fatal — swap succeeded but persistence failed
+        }
+        this._emit({ type: 'WORKSPACE_SWAP_COMPLETED', from, to: resolved, persistedInDaemonSettings });
+        return { ok: true, previous: from, current: resolved };
+    }
+    // ---------------------------------------------------------------------------
+    // Internal helpers
+    // ---------------------------------------------------------------------------
+    _emit(payload) {
+        if (!this.deps.runtimeBus)
+            return;
+        try {
+            const envelope = createEventEnvelope(payload.type, payload, { sessionId: '', source: 'workspace-swap-manager' });
+            this.deps.runtimeBus.emit('workspace', 
+            // WorkspaceEvent is the DomainEventMap['workspace'] union; createEventEnvelope
+            // infers the payload type as the concrete member rather than the full union.
+            // A single widening cast (not through unknown) is safe here.
+            envelope);
+        }
+        catch {
+            // Never throw from event emission
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-sdk",
-  "version": "0.21.18",
+  "version": "0.21.21",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mgd34msu/goodvibes-sdk.git"