@claude-flow/cli 3.71.2 → 3.71.4

package/dist/src/mods/headless-plugins.d.ts

@@ -14,10 +14,20 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { type ResolveOptions, type PluginPaths } from './plugin-paths.js';
 export declare const DEFAULT_WORKER_PLUGINS: readonly string[];
 export declare const PROFILE_ENV = "RUFLO_HEADLESS_PLUGINS";
+export declare const PERMISSION_MODE_ENV = "RUFLO_HEADLESS_PERMISSION_MODE";
+export declare const DEFAULT_HEADLESS_PERMISSION_MODE = "auto";
 export interface HeadlessPluginOptions extends ResolveOptions {
     /** Plugin names to load; defaults to the env profile, else DEFAULT_WORKER_PLUGINS. */
     profile?: readonly string[];
@@ -40,5 +50,11 @@ export declare function resetHeadlessPluginWarnings(): void;
 export declare function workerProfile(env?: NodeJS.ProcessEnv, explicit?: readonly string[]): string[];
 /** Every `--plugin-dir` value already in argv (both `--plugin-dir x` and `--plugin-dir=x`). */
 export declare function existingPluginDirs(argv: readonly string[]): string[];
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export declare function headlessPermissionArgs(argv: readonly string[], env?: NodeJS.ProcessEnv): string[];
 export declare function withHeadlessPlugins<E extends Record<string, string | undefined>>(argv: readonly string[], env: E, opts?: HeadlessPluginOptions): HeadlessPluginResult<E>;
 //# sourceMappingURL=headless-plugins.d.ts.map

package/dist/src/mods/headless-plugins.js

@@ -14,6 +14,14 @@
  *
  * Profile override: `RUFLO_HEADLESS_PLUGINS` is a comma list of plugin names;
  * `none` (or an empty value) turns plugin loading off.
+ *
+ * Permission mode: Claude Code 2.1.302 starts a `claude -p` with no
+ * permission mode in `manual` mode on third-party providers, with telemetry
+ * off, or on a fresh install. A headless worker has nobody to answer a prompt,
+ * so a print-mode argv without its own `--permission-mode` or
+ * `--dangerously-skip-permissions` gets `--permission-mode auto` — the mode
+ * first-party installs already started in. `RUFLO_HEADLESS_PERMISSION_MODE`
+ * picks another mode; `none` (or an empty value) passes no flag.
  */
 import { realpathSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
@@ -21,6 +29,9 @@ import { ENABLE_ENV } from './install.js';
 import { resolvePluginPaths } from './plugin-paths.js';
 export const DEFAULT_WORKER_PLUGINS = ['ruflo-mods'];
 export const PROFILE_ENV = 'RUFLO_HEADLESS_PLUGINS';
+export const PERMISSION_MODE_ENV = 'RUFLO_HEADLESS_PERMISSION_MODE';
+export const DEFAULT_HEADLESS_PERMISSION_MODE = 'auto';
+const PERMISSION_MODES = new Set(['acceptEdits', 'auto', 'bypassPermissions', 'manual', 'default', 'dontAsk', 'plan']);
 const warned = new Set();
 /** For tests: forget which missing plugins were already logged. */
 export function resetHeadlessPluginWarnings() {
@@ -56,9 +67,27 @@ export function existingPluginDirs(argv) {
     }
     return dirs;
 }
+/**
+ * The `--permission-mode` args to append to a headless argv: none when the
+ * argv is not print mode or already sets a mode, else the env choice
+ * (default `auto`). An unknown mode is ignored with the default used instead.
+ */
+export function headlessPermissionArgs(argv, env = process.env) {
+    const isPrint = argv.some((a) => a === '-p' || a === '--print');
+    if (!isPrint)
+        return [];
+    const hasMode = argv.some((a) => a === '--permission-mode' || a.startsWith('--permission-mode=') || a === '--dangerously-skip-permissions');
+    if (hasMode)
+        return [];
+    const raw = env[PERMISSION_MODE_ENV];
+    if (raw !== undefined && (raw.trim() === '' || raw.trim().toLowerCase() === 'none'))
+        return [];
+    const mode = raw !== undefined && PERMISSION_MODES.has(raw.trim()) ? raw.trim() : DEFAULT_HEADLESS_PERMISSION_MODE;
+    return ['--permission-mode', mode];
+}
 export function withHeadlessPlugins(argv, env, opts = {}) {
     const profile = workerProfile(opts.env ?? env, opts.profile);
-    const outArgv = [...argv];
+    const outArgv = [...argv, ...headlessPermissionArgs(argv, opts.env ?? env)];
     const outEnv = { ...env };
     if (profile.length === 0)
         return { argv: outArgv, env: outEnv, added: [], missing: [] };

package/dist/src/services/daemon-autostart.d.ts

@@ -1,5 +1,29 @@
 /** True if a live daemon already holds the project's pidfile. */
 export declare function isDaemonAlive(projectRoot: string): boolean;
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export declare const DAEMON_STOP_MARKER = "daemon.stopped";
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export declare const AUTOSTART_ENV = "RUFLO_DAEMON_AUTOSTARTED";
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export declare function isDaemonStopMarked(projectRoot: string): boolean;
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export declare function writeDaemonStopMarker(projectRoot: string): boolean;
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export declare function clearDaemonStopMarker(projectRoot: string): void;
 /**
  * Return true only when the directory contains a durable Ruflo project marker.
  *

package/dist/src/services/daemon-autostart.js

@@ -81,6 +81,57 @@ function autostartDisabledByProjectConfig(projectRoot) {
     }
     return false;
 }
+/**
+ * #4654: an explicit `daemon stop` is an opt-out that must survive the next
+ * hook. Every ruflo-core plugin hook (PreToolUse/PostToolUse, PreCompact, Stop)
+ * runs the CLI, and the CLI auto-starts a daemon whenever none is alive, so a
+ * stopped daemon came back within minutes. `daemon stop` now writes this
+ * marker, auto-start honours it, and only an explicit `daemon start` clears it.
+ */
+export const DAEMON_STOP_MARKER = 'daemon.stopped';
+/**
+ * Set on the daemon that auto-start spawns, so that spawned `daemon start` does
+ * not clear a stop marker written after auto-start checked it (a `daemon stop`
+ * racing a hook). Only a user-driven start clears the marker.
+ */
+export const AUTOSTART_ENV = 'RUFLO_DAEMON_AUTOSTARTED';
+function stopMarkerPath(projectRoot) {
+    return path.join(projectRoot, '.claude-flow', DAEMON_STOP_MARKER);
+}
+/** True if the user explicitly stopped the daemon for this project (#4654). */
+export function isDaemonStopMarked(projectRoot) {
+    try {
+        return fs.existsSync(stopMarkerPath(projectRoot));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Record an explicit `daemon stop` (#4654). Writes only into a directory that is
+ * already a Ruflo project or already has `.claude-flow/`, so `daemon stop` in an
+ * unrelated directory does not litter it. Best-effort; never throws.
+ */
+export function writeDaemonStopMarker(projectRoot) {
+    try {
+        const dir = path.join(projectRoot, '.claude-flow');
+        if (!fs.existsSync(dir) && !isRufloProject(projectRoot))
+            return false;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(stopMarkerPath(projectRoot), JSON.stringify({ stoppedAt: new Date().toISOString(), pid: process.pid }) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Clear the stop marker. Called by an explicit `daemon start` (#4654). Never throws. */
+export function clearDaemonStopMarker(projectRoot) {
+    try {
+        fs.unlinkSync(stopMarkerPath(projectRoot));
+    }
+    catch { /* absent */ }
+}
 function autostartDisabled(projectRoot) {
     if (/^(0|false|no|off)$/i.test(process.env.RUFLO_DAEMON_AUTOSTART ?? ''))
         return true;
@@ -166,7 +217,7 @@ const defaultSpawn = (projectRoot) => {
         cwd: projectRoot,
         detached: true,
         stdio: 'ignore',
-        env: { ...process.env },
+        env: { ...process.env, [AUTOSTART_ENV]: '1' },
     });
     child.unref();
 };
@@ -186,6 +237,9 @@ export function ensureDaemonRunning(startDir, opts = {}) {
         if (!isRufloProject(projectRoot)) {
             return { started: false, reason: 'not a ruflo project' };
         }
+        if (isDaemonStopMarked(projectRoot)) {
+            return { started: false, reason: 'stopped by user (daemon stop); run `daemon start` to re-enable' };
+        }
         const alive = (opts.isAlive ?? isDaemonAlive)(projectRoot);
         if (alive)
             return { started: false, reason: 'already running' };

package/dist/src/services/headless-worker-executor.d.ts

@@ -123,6 +123,12 @@ export interface HeadlessExecutionResult {
     inputTokens?: number;
     outputTokens?: number;
     costUsd?: number;
+    /**
+     * When the stored claude.ai sign-in the worker ran under ends (ISO 8601),
+     * from `credential_expires_at` in the `claude -p` JSON result (Claude Code
+     * 2.1.318+). Absent for API-key auth and older CLIs.
+     */
+    credentialExpiresAt?: string;
     /** Model used for execution */
     model: string;
     /** Sandbox mode used */
@@ -202,7 +208,16 @@ export interface ClaudePrintEnvelope {
     outputTokens?: number;
     costUsd?: number;
     durationMs?: number;
+    /** ISO 8601 end of the stored claude.ai sign-in (Claude Code 2.1.318+). */
+    credentialExpiresAt?: string;
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export declare const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export declare function normalizeCredentialExpiry(v: unknown): string | undefined;
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of

package/dist/src/services/headless-worker-executor.js

@@ -337,6 +337,23 @@ export function isLocalWorker(type) {
 export function getModelId(model) {
     return MODEL_IDS[model];
 }
+/** Days before a sign-in ends at which the executor emits 'credential-expiring' (matches Claude Code's own stderr warning). */
+export const CREDENTIAL_EXPIRY_WARN_DAYS = 10;
+/**
+ * Normalise `credential_expires_at` to ISO 8601. Accepts an ISO string or an
+ * epoch number (seconds or milliseconds); anything else is undefined.
+ */
+export function normalizeCredentialExpiry(v) {
+    let ms;
+    if (typeof v === 'number' && Number.isFinite(v) && v > 0)
+        ms = v < 1e12 ? v * 1000 : v;
+    else if (typeof v === 'string' && v.trim()) {
+        const t = Date.parse(v);
+        if (Number.isFinite(t))
+            ms = t;
+    }
+    return ms === undefined ? undefined : new Date(ms).toISOString();
+}
 /**
  * #2661 root-fix — best-effort parse of `claude --print --output-format
  * json`'s response envelope. Deliberately lenient: probes a couple of
@@ -371,6 +388,7 @@ export function parseClaudePrintJsonEnvelope(raw) {
         outputTokens: numOrUndef(usage?.output_tokens ?? usage?.outputTokens),
         costUsd: numOrUndef(obj.total_cost_usd ?? obj.cost_usd ?? obj.totalCostUsd),
         durationMs: numOrUndef(obj.duration_ms ?? obj.durationMs),
+        credentialExpiresAt: normalizeCredentialExpiry(obj.credential_expires_at ?? obj.credentialExpiresAt),
     };
 }
 /**
@@ -779,7 +797,16 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                 executionId,
                 error: result.error,
                 ...(result.missingPlugins ? { missingPlugins: result.missingPlugins } : {}),
+                ...(result.credentialExpiresAt ? { credentialExpiresAt: result.credentialExpiresAt } : {}),
             };
+            // Claude Code 2.1.318: surface a claude.ai sign-in that ends soon, so the
+            // daemon can say so before workers start failing on auth.
+            if (result.credentialExpiresAt) {
+                const daysLeft = (Date.parse(result.credentialExpiresAt) - Date.now()) / 86_400_000;
+                if (daysLeft <= CREDENTIAL_EXPIRY_WARN_DAYS) {
+                    this.emit('credential-expiring', { expiresAt: result.credentialExpiresAt, daysLeft: Math.max(0, Math.floor(daysLeft)), workerType });
+                }
+            }
             // Log result
             this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
             // #2661 root-fix — structured per-launch telemetry, receipted
@@ -1182,6 +1209,7 @@ Analyze the above codebase context and provide your response following the forma
                         : undefined,
                     costUsd: envelope?.costUsd,
                     apiDurationMs: envelope?.durationMs,
+                    credentialExpiresAt: envelope?.credentialExpiresAt,
                     error: code !== 0 ? stderr || `Process exited with code ${code}` : undefined,
                 });
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-flow/cli",
-  "version": "3.71.2",
+  "version": "3.71.4",
   "type": "module",
   "description": "Ruflo CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",