@love-moon/conductor-sdk 0.7.5 → 0.7.7

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @love-moon/conductor-sdk
 
+## 0.7.7
+
+### Patch Changes
+
+- 400f3a7: Report a terminal task status when a stop request finds no active process, so a
+  task whose Fire already died converges instead of sitting in `killing` forever.
+
+  Drop queued terminal status events before an in-place restart reuses a working
+  directory. The durable upstream outbox lives inside that directory, so an
+  undelivered `KILLED` from the previous run was flushed on startup and killed the
+  task that had just finished resuming.
+
+## 0.7.6
+
+### Patch Changes
+
+- 7bbb412: Add `CONDUCTOR_HOME` support for relocating user-level configuration, logs,
+  Fire locks, sessions, update metadata, and AI manager caches while leaving
+  project-scoped `.conductor` directories and Fire task markers in place.
+
+  Migrate device authorization to `conductor.conductor-ai.top` while preserving
+  compatibility with the legacy official endpoint and self-hosted backends.
+
 ## 0.7.5
 
 ## 0.7.4

package/dist/client.js

@@ -54,7 +54,7 @@ export class ConductorClient {
         const projectPath = options.projectPath ?? process.cwd();
         const backendApi = options.backendApi ?? new BackendApiClient(config);
         const sessions = options.sessionManager ?? new SessionManager();
-        const sessionStore = options.sessionStore ?? SessionDiskStore.forBackendUrl(config.backendUrl);
+        const sessionStore = options.sessionStore ?? SessionDiskStore.forBackendUrl(config.backendUrl, env);
         const messageRouter = options.messageRouter ?? new MessageRouter(sessions);
         const agentHost = resolveAgentHost(env, options.agentHost);
         const deliveryScopeId = normalizeDeliveryScopeId(options.deliveryScopeId ?? `agent:${agentHost}`);

package/dist/config/index.js

@@ -1,13 +1,11 @@
 import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import yaml from 'yaml';
+import { resolveConductorConfigPath } from '../paths.js';
 export const CONFIG_ENV_VAR = 'CONDUCTOR_CONFIG';
 export const AGENT_TOKEN_ENV_VAR = 'CONDUCTOR_AGENT_TOKEN';
 export const BACKEND_URL_ENV_VAR = 'CONDUCTOR_BACKEND_URL';
 export const WS_URL_ENV_VAR = 'CONDUCTOR_WS_URL';
 export const LOG_LEVEL_ENV_VAR = 'CONDUCTOR_LOG_LEVEL';
-const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.conductor', 'config.yaml');
 const ALLOWED_LOG_LEVELS = new Set(['debug', 'info', 'warning', 'error', 'critical']);
 export class ConfigError extends Error {
 }
@@ -97,21 +95,12 @@ export function loadConfig(targetPath, options = {}) {
     });
 }
 function resolveConfigPath(explicitPath, env) {
-    const candidate = explicitPath ||
-        env[CONFIG_ENV_VAR] ||
-        DEFAULT_CONFIG_PATH;
-    const normalized = normalizePath(candidate);
+    const normalized = resolveConductorConfigPath(explicitPath, env);
     if (!fs.existsSync(normalized)) {
         throw new ConfigFileNotFound(normalized);
     }
     return normalized;
 }
-function normalizePath(value) {
-    const expanded = value.startsWith('~')
-        ? path.join(os.homedir(), value.slice(1))
-        : value;
-    return path.resolve(expanded);
-}
 function readYaml(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8');
     let parsed;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './paths.js';
 export * from './config/index.js';
 export * from './backend/index.js';
 export * from './ws/index.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './paths.js';
 export * from './config/index.js';
 export * from './backend/index.js';
 export * from './ws/index.js';

package/dist/outbox/store.d.ts

@@ -21,6 +21,30 @@ export declare class DurableUpstreamOutboxStore {
         payload: Record<string, unknown>;
     }): DurableUpstreamEvent;
     remove(stableId: string): void;
+    /**
+     * Discard queued terminal `task_status_update` events (KILLED / COMPLETED).
+     *
+     * This outbox lives INSIDE the fire's working directory, and an in-place
+     * restart deliberately re-uses that same directory (the daemon sets
+     * `CONDUCTOR_RESUME_CWD` so `--resume` finds the original project). That
+     * means a terminal status the PREVIOUS run failed to deliver — e.g. its
+     * websocket dropped while it was being stopped — is still sitting on disk
+     * when the NEXT run starts, and the startup flush delivers it against the
+     * task that was just brought back to life. The server marks the task
+     * `killed`, then answers the newly-attached fire with
+     * `stop_task(task_already_killed)` and shoots it down seconds after it
+     * finished resuming.
+     *
+     * A terminal status from a superseded run is definitionally obsolete: the
+     * task has since been restarted, so "that run ended" is no longer news the
+     * server can act on correctly. Drop those and keep everything else —
+     * `sdk_message` entries are real conversation content that must still be
+     * delivered, and `task_stop_ack` / `agent_command_ack` are idempotent
+     * bookkeeping whose delivery actually clears stale server-side outbox rows.
+     *
+     * Returns the dropped entries so callers can log exactly what was discarded.
+     */
+    dropPendingTerminalStatusEvents(): DurableUpstreamEvent[];
     markRetry(stableId: string, delayMs: number): DurableUpstreamEvent | null;
     listReady(nowMs?: number): DurableUpstreamEvent[];
     nextRetryDelay(nowMs?: number): number | null;

package/dist/outbox/store.js

@@ -19,6 +19,16 @@ const sleepSync = (ms) => {
         }
     }
 };
+// Terminal statuses as published by `conductor daemon` (see cli/src/daemon.js,
+// which sends the upper-case wire form). Compared case-insensitively so a
+// future lower-case producer does not silently bypass the check.
+const TERMINAL_TASK_STATUSES = new Set(['killed', 'completed']);
+const isTerminalStatusEvent = (entry) => {
+    if (entry.eventType !== 'task_status_update')
+        return false;
+    const status = entry.payload?.status;
+    return typeof status === 'string' && TERMINAL_TASK_STATUSES.has(status.trim().toLowerCase());
+};
 const sanitizeScopeId = (scopeId) => scopeId
     .trim()
     .replace(/[^a-zA-Z0-9._-]+/g, '_')
@@ -66,6 +76,40 @@ export class DurableUpstreamOutboxStore {
             this.saveUnlocked(entries);
         });
     }
+    /**
+     * Discard queued terminal `task_status_update` events (KILLED / COMPLETED).
+     *
+     * This outbox lives INSIDE the fire's working directory, and an in-place
+     * restart deliberately re-uses that same directory (the daemon sets
+     * `CONDUCTOR_RESUME_CWD` so `--resume` finds the original project). That
+     * means a terminal status the PREVIOUS run failed to deliver — e.g. its
+     * websocket dropped while it was being stopped — is still sitting on disk
+     * when the NEXT run starts, and the startup flush delivers it against the
+     * task that was just brought back to life. The server marks the task
+     * `killed`, then answers the newly-attached fire with
+     * `stop_task(task_already_killed)` and shoots it down seconds after it
+     * finished resuming.
+     *
+     * A terminal status from a superseded run is definitionally obsolete: the
+     * task has since been restarted, so "that run ended" is no longer news the
+     * server can act on correctly. Drop those and keep everything else —
+     * `sdk_message` entries are real conversation content that must still be
+     * delivered, and `task_stop_ack` / `agent_command_ack` are idempotent
+     * bookkeeping whose delivery actually clears stale server-side outbox rows.
+     *
+     * Returns the dropped entries so callers can log exactly what was discarded.
+     */
+    dropPendingTerminalStatusEvents() {
+        return this.withLock(() => {
+            const entries = this.loadUnlocked();
+            const dropped = entries.filter(isTerminalStatusEvent);
+            if (dropped.length === 0) {
+                return [];
+            }
+            this.saveUnlocked(entries.filter((entry) => !isTerminalStatusEvent(entry)));
+            return dropped;
+        });
+    }
     markRetry(stableId, delayMs) {
         return this.withLock(() => {
             const entries = this.loadUnlocked();

package/dist/paths.d.ts

@@ -0,0 +1,7 @@
+export declare const CONDUCTOR_HOME_ENV_VAR = "CONDUCTOR_HOME";
+export declare const CONDUCTOR_CONFIG_ENV_VAR = "CONDUCTOR_CONFIG";
+export type ConductorPathEnv = Record<string, string | undefined>;
+export declare function resolveUserHome(env?: ConductorPathEnv, fallbackHome?: string): string;
+export declare function resolveHomeRelativePath(value: string, env?: ConductorPathEnv, fallbackHome?: string): string;
+export declare function resolveConductorHome(env?: ConductorPathEnv): string;
+export declare function resolveConductorConfigPath(explicitPath?: string, env?: ConductorPathEnv): string;

package/dist/paths.js

@@ -0,0 +1,39 @@
+import os from 'node:os';
+import path from 'node:path';
+export const CONDUCTOR_HOME_ENV_VAR = 'CONDUCTOR_HOME';
+export const CONDUCTOR_CONFIG_ENV_VAR = 'CONDUCTOR_CONFIG';
+function normalizeOptionalString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+export function resolveUserHome(env = process.env, fallbackHome = os.homedir()) {
+    return normalizeOptionalString(env.HOME)
+        || normalizeOptionalString(env.USERPROFILE)
+        || normalizeOptionalString(fallbackHome)
+        || '/tmp';
+}
+export function resolveHomeRelativePath(value, env = process.env, fallbackHome = os.homedir()) {
+    const normalized = normalizeOptionalString(value);
+    const userHome = resolveUserHome(env, fallbackHome);
+    if (normalized === '~') {
+        return path.resolve(userHome);
+    }
+    if (normalized.startsWith('~/') || normalized.startsWith('~\\')) {
+        return path.resolve(userHome, normalized.slice(2));
+    }
+    return path.resolve(normalized);
+}
+export function resolveConductorHome(env = process.env) {
+    const configuredHome = normalizeOptionalString(env[CONDUCTOR_HOME_ENV_VAR]);
+    if (configuredHome) {
+        return resolveHomeRelativePath(configuredHome, env);
+    }
+    return path.join(path.resolve(resolveUserHome(env)), '.conductor');
+}
+export function resolveConductorConfigPath(explicitPath, env = process.env) {
+    const configuredPath = normalizeOptionalString(explicitPath)
+        || normalizeOptionalString(env[CONDUCTOR_CONFIG_ENV_VAR]);
+    if (configuredPath) {
+        return resolveHomeRelativePath(configuredPath, env);
+    }
+    return path.join(resolveConductorHome(env), 'config.yaml');
+}

package/dist/session/store.d.ts

@@ -1,3 +1,4 @@
+import { type ConductorPathEnv } from '../paths.js';
 export declare const DEFAULT_SESSION_DIR: string;
 export declare const DEFAULT_SESSION_PATH: string;
 export declare const DEFAULT_SESSION_ENV = "CODEX_SESSION_ID";
@@ -29,9 +30,10 @@ export declare class SessionDiskStore {
     constructor(filePath?: string);
     /**
      * Create a SessionDiskStore for a specific backend URL.
-     * Sessions are stored in ~/.conductor/sessions/<host>.yaml
+     * Sessions are stored in $CONDUCTOR_HOME/sessions/<host>.yaml.
+     * When CONDUCTOR_HOME is unset, it defaults to ~/.conductor.
      */
-    static forBackendUrl(backendUrl: string): SessionDiskStore;
+    static forBackendUrl(backendUrl: string, env?: ConductorPathEnv): SessionDiskStore;
     load(): SessionRecord[];
     private loadUnlocked;
     save(records: SessionRecord[]): void;

package/dist/session/store.js

@@ -2,8 +2,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import yaml from 'yaml';
-export const DEFAULT_SESSION_DIR = path.join(os.homedir(), '.conductor', 'sessions');
-export const DEFAULT_SESSION_PATH = path.join(os.homedir(), '.conductor', 'session.yaml');
+import { resolveConductorHome } from '../paths.js';
+export const DEFAULT_SESSION_DIR = path.join(resolveConductorHome(), 'sessions');
+export const DEFAULT_SESSION_PATH = path.join(resolveConductorHome(), 'session.yaml');
 export const DEFAULT_SESSION_ENV = 'CODEX_SESSION_ID';
 export const DEFAULT_SESSION_FALLBACK_ENV = 'SESSION_ID';
 const SESSION_LOCK_TIMEOUT_MS = 10_000;
@@ -81,17 +82,18 @@ export class SessionRecord {
 export class SessionDiskStore {
     filePath;
     lockPath;
-    constructor(filePath = DEFAULT_SESSION_PATH) {
+    constructor(filePath = path.join(resolveConductorHome(), 'session.yaml')) {
         this.filePath = path.resolve(filePath);
         this.lockPath = `${this.filePath}.lock`;
     }
     /**
      * Create a SessionDiskStore for a specific backend URL.
-     * Sessions are stored in ~/.conductor/sessions/<host>.yaml
+     * Sessions are stored in $CONDUCTOR_HOME/sessions/<host>.yaml.
+     * When CONDUCTOR_HOME is unset, it defaults to ~/.conductor.
      */
-    static forBackendUrl(backendUrl) {
+    static forBackendUrl(backendUrl, env = process.env) {
         const host = extractHostKey(backendUrl);
-        const filePath = path.join(DEFAULT_SESSION_DIR, `${host}.yaml`);
+        const filePath = path.join(resolveConductorHome(env), 'sessions', `${host}.yaml`);
         return new SessionDiskStore(filePath);
     }
     load() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@love-moon/conductor-sdk",
-  "version": "0.7.5",
+  "version": "0.7.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lovemoon-ai/conductor.git"
@@ -33,5 +33,5 @@
     "typescript": "^5.6.3",
     "vitest": "^2.1.4"
   },
-  "gitCommitId": "702c7c4"
+  "gitCommitId": "26b2dbb"
 }