@dinoxx/dinox-cli 2.6.0 → 2.8.0

package/dist/commands/gateway/index.js

@@ -291,7 +291,7 @@ export const gatewayCommandGroup = {
         },
         {
             name: 'mcp',
-            description: 'Serve read-only Dinox knowledge tools over stdio MCP (started by gateway agents)',
+            description: 'Serve Dinox tools over stdio MCP: read-only knowledge tools and send_file (started by gateway agents)',
             schema: {
                 path: 'gateway.mcp',
                 risk: 'read',

package/dist/commands/schema/renderSkills.js

@@ -4,7 +4,7 @@ import { listErrorCodes } from '../../utils/errorCodes.js';
 import { listCommandSchemas } from './spec.js';
 const SECTION_ORDER = [
     { title: 'Auth', paths: ['auth.login', 'auth.logout', 'auth.status'] },
-    { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop', 'daemon.install', 'daemon.uninstall'] },
+    { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop', 'daemon.install', 'daemon.uninstall', 'daemon.supervise'] },
     {
         title: 'Agent Gateways',
         paths: ['gateway.detect', 'gateway.add', 'gateway.list', 'gateway.remove', 'gateway.status', 'gateway.reload', 'gateway.mcp'],

package/dist/commands/storage/repo/remote.d.ts

@@ -28,5 +28,5 @@ export declare function defaultUploadBytes(input: {
 }): Promise<UploadObjectResult>;
 type SharpFactory = typeof import('sharp');
 export declare function loadSharp(): Promise<SharpFactory>;
-export declare function generateThumbnailBuffer(sharp: SharpFactory, localPath: string): Promise<Buffer>;
+export declare function generateThumbnailBuffer(sharp: SharpFactory, input: string | Buffer): Promise<Buffer>;
 export {};

package/dist/commands/storage/repo/remote.js

@@ -124,8 +124,8 @@ export async function loadSharp() {
         });
     }
 }
-export async function generateThumbnailBuffer(sharp, localPath) {
-    return sharp(localPath)
+export async function generateThumbnailBuffer(sharp, input) {
+    return sharp(input)
         .resize({ width: 400, withoutEnlargement: true })
         .webp({ quality: 50 })
         .toBuffer();

package/dist/daemon/index.js

@@ -16,6 +16,7 @@ import { getPackageVersion } from '../utils/version.js';
 import { DAEMON_CHILD_ENV, daemonServiceSpec, envTokenOverridesLogin, launchDaemon } from './launch.js';
 import { getDaemonLogPath, rotateDaemonLog, writeDaemonLogLine } from './log.js';
 import { DAEMON_SERVICE_ENV, getDaemonService } from './supervisor.js';
+import { superviseCurrentDaemon } from './supervise.js';
 import { normalizeAuthToken } from '../utils/authToken.js';
 const DAEMON_STOP_POLL_INTERVAL_MS = 100;
 const DAEMON_STOP_TIMEOUT_MS = 5_000;
@@ -380,11 +381,20 @@ export async function uninstallDaemonService() {
     if (!service) {
         return { uninstalled: false, service: null, definitionPath: null };
     }
-    return withDaemonStartLock(async () => ({
-        uninstalled: await service.uninstall(),
-        service: service.kind,
-        definitionPath: service.definitionPath,
-    }));
+    return withDaemonStartLock(async () => {
+        if (service.isInstalled()) {
+            // Stop through the socket first: a clean exit is not restarted, and
+            // deleting a Windows task does not end the process it started.
+            const info = await getDaemonInfo();
+            if (info?.supervisor === service.kind)
+                await stopDaemonLocked();
+        }
+        return {
+            uninstalled: await service.uninstall(),
+            service: service.kind,
+            definitionPath: service.definitionPath,
+        };
+    });
 }
 function printDaemonStartResult(result) {
     if (result.alreadyRunning) {
@@ -432,7 +442,7 @@ function printDaemonInstallResult(result) {
     printHumanReadableLine(`Installed ${result.service} service ${result.label}`);
     printHumanReadableLine(`Definition: ${result.definitionPath}`);
     printHumanReadableLine(`Log: ${result.logPath}`);
-    printHumanReadableLine('The daemon now starts at login and restarts after a crash.');
+    printHumanReadableLine(`The daemon now starts at ${result.service === 'schtasks' ? 'logon (Task Scheduler)' : 'login'} and restarts after a crash.`);
     if (result.service === 'systemd') {
         printHumanReadableLine('To keep it running after you log out, run `loginctl enable-linger`.');
     }
@@ -482,6 +492,9 @@ async function runDaemonStatus() {
     }
     printDaemonStatusResult(result);
 }
+async function runDaemonSupervise(context) {
+    process.exitCode = await superviseCurrentDaemon(parsePort(context.options.port));
+}
 async function runDaemonInstall(context) {
     const result = await installDaemonService(parsePort(context.options.port));
     if (getRequestedStructuredOutputFormat()) {
@@ -620,6 +633,24 @@ export const daemonCommandGroup = {
             },
             action: runDaemonUninstall,
         },
+        {
+            name: 'supervise',
+            description: 'Run the daemon in the foreground and restart it after a crash (used by the Windows logon task)',
+            options: [{ flags: '--port <number>', description: 'Legacy compatibility field; daemon listens on a private local socket', type: 'number', defaultValue: DEFAULT_DAEMON_PORT }],
+            schema: {
+                path: 'daemon.supervise',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: [],
+                output: {
+                    type: 'structured',
+                    summary: 'Runs until the daemon exits cleanly or the supervisor is stopped; no structured payload',
+                    fields: [],
+                },
+                examples: ['dino daemon supervise'],
+            },
+            action: runDaemonSupervise,
+        },
     ],
 };
 export function registerDaemonCommands(program) {

package/dist/daemon/launch.d.ts

@@ -14,7 +14,11 @@ export type DaemonLaunch = {
  * of its own environment can have.
  */
 export declare function envTokenOverridesLogin(raw: DinoxConfig, env?: NodeJS.ProcessEnv): boolean;
-/** What the service definition runs: this CLI, with no secrets written to disk. */
+/**
+ * What the service definition runs: this CLI, with no secrets written to disk.
+ * Task Scheduler cannot restart a crashed process, so on Windows the service
+ * runs the supervisor, which runs the daemon.
+ */
 export declare function daemonServiceSpec(service: DaemonService, port: number): DaemonServiceSpec;
 /** The installed service when this caller can use it, else null. */
 export declare function usableDaemonService(): Promise<DaemonService | null>;

package/dist/daemon/launch.js

@@ -6,17 +6,19 @@ import { DinoxError } from '../utils/errors.js';
 import { buildDaemonEnv } from './env.js';
 import { closeDaemonLogFd, getDaemonLogPath, openDaemonLogForChild } from './log.js';
 import { ensureDaemonDir } from './pid.js';
-import { DAEMON_SERVICE_ENV, getDaemonService, serviceDefinitionIsStale, } from './supervisor.js';
+import { DAEMON_SERVICE_ENV, getDaemonService, } from './supervisor.js';
 /** Tells a daemon child its parent holds the start lock (or that it runs under a service). */
 export const DAEMON_CHILD_ENV = 'DINOX_INTERNAL_DAEMON_CHILD';
-function daemonCommandLine(port) {
+function daemonCommandLine(port, mode = 'start') {
     const entrypoint = process.argv[1];
     if (!entrypoint) {
         throw new DinoxError('Cannot determine the CLI entrypoint for daemon startup', { code: 'DAEMON_START_FAILED' });
     }
     return {
         program: process.execPath,
-        args: [...process.execArgv, entrypoint, 'daemon', 'start', '--port', String(port), '--no-detach'],
+        args: mode === 'supervise'
+            ? [...process.execArgv, entrypoint, 'daemon', 'supervise', '--port', String(port)]
+            : [...process.execArgv, entrypoint, 'daemon', 'start', '--port', String(port), '--no-detach'],
     };
 }
 /**
@@ -28,9 +30,13 @@ export function envTokenOverridesLogin(raw, env = process.env) {
     const envToken = readEnvAuthToken(env);
     return Boolean(envToken && envToken !== normalizeAuthToken(raw.auth?.authorization));
 }
-/** What the service definition runs: this CLI, with no secrets written to disk. */
+/**
+ * What the service definition runs: this CLI, with no secrets written to disk.
+ * Task Scheduler cannot restart a crashed process, so on Windows the service
+ * runs the supervisor, which runs the daemon.
+ */
 export function daemonServiceSpec(service, port) {
-    const { program, args } = daemonCommandLine(port);
+    const { program, args } = daemonCommandLine(port, service.kind === 'schtasks' ? 'supervise' : 'start');
     const env = buildDaemonEnv();
     delete env[DINOX_TOKEN_ENV_VAR];
     env[DAEMON_SERVICE_ENV] = service.kind;
@@ -55,6 +61,8 @@ function spawnDetached(port) {
             stdio: ['ignore', log, log],
             env: { ...buildDaemonEnv(), [DAEMON_CHILD_ENV]: '1' },
             cwd: os.homedir(),
+            // A detached Windows child otherwise opens its own console window.
+            windowsHide: true,
         });
         child.unref();
         return { service: null, abort: () => child.kill('SIGTERM') };
@@ -75,7 +83,7 @@ export async function launchDaemon(port) {
         return spawnDetached(port);
     ensureDaemonDir();
     const spec = daemonServiceSpec(service, port);
-    if (serviceDefinitionIsStale(service, spec)) {
+    if (!service.isCurrent(spec)) {
         await service.install(spec);
     }
     else {

package/dist/daemon/log.d.ts

@@ -10,3 +10,5 @@ export declare function openDaemonLogForChild(): number | 'ignore';
 export declare function closeDaemonLogFd(fd: number | 'ignore'): void;
 /** One timestamped line on stderr, which a daemon child has pointed at its log. */
 export declare function writeDaemonLogLine(scope: string, message: string, details?: Record<string, unknown>): void;
+/** One timestamped line appended to the log file itself, for processes with no usable stderr. */
+export declare function appendDaemonLogLine(scope: string, message: string, details?: Record<string, unknown>): void;

package/dist/daemon/log.js

@@ -1,4 +1,4 @@
-import { closeSync, copyFileSync, openSync, statSync, truncateSync } from 'node:fs';
+import { appendFileSync, closeSync, copyFileSync, openSync, statSync, truncateSync } from 'node:fs';
 import { join } from 'node:path';
 import { ensureDaemonDir, getDaemonDir } from './pid.js';
 const MAX_DAEMON_LOG_BYTES = 5 * 1024 * 1024;
@@ -37,8 +37,21 @@ export function closeDaemonLogFd(fd) {
     if (fd !== 'ignore')
         closeSync(fd);
 }
+function formatLogLine(scope, message, details) {
+    const suffix = details ? ` ${JSON.stringify(details)}` : '';
+    return `${new Date().toISOString()} [${scope}] ${message}${suffix}\n`;
+}
 /** One timestamped line on stderr, which a daemon child has pointed at its log. */
 export function writeDaemonLogLine(scope, message, details) {
-    const suffix = details ? ` ${JSON.stringify(details)}` : '';
-    process.stderr.write(`${new Date().toISOString()} [${scope}] ${message}${suffix}\n`);
+    process.stderr.write(formatLogLine(scope, message, details));
+}
+/** One timestamped line appended to the log file itself, for processes with no usable stderr. */
+export function appendDaemonLogLine(scope, message, details) {
+    try {
+        ensureDaemonDir();
+        appendFileSync(getDaemonLogPath(), formatLogLine(scope, message, details), { mode: 0o600 });
+    }
+    catch {
+        // Logging is best effort.
+    }
 }

package/dist/daemon/server.js

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto';
 import { createServer } from 'http';
 import { chmodSync, existsSync } from 'node:fs';
+import path from 'node:path';
 import { DAEMON_SERVICE_ENV } from './supervisor.js';
 import { writeDaemonLogLine } from './log.js';
 import { loadConfig } from '../config/store.js';
@@ -21,7 +22,7 @@ import { readConversation } from '../gateway/conversationContext.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
 function daemonSupervisor() {
     const value = process.env[DAEMON_SERVICE_ENV];
-    return value === 'launchd' || value === 'systemd' ? value : null;
+    return value === 'launchd' || value === 'systemd' || value === 'schtasks' ? value : null;
 }
 const DAEMON_PROCESS_VERSION = getPackageVersion();
 async function readJsonBody(req) {
@@ -183,6 +184,21 @@ export class DaemonServer {
                     }
                     return { id: req.id, ok: true, result: { gateways: await this.gateways.reload() } };
                 }
+                case 'gateway.sendFile': {
+                    if (!this.gateways) {
+                        throw new DinoxError('Gateways need a signed-in daemon', { code: 'AUTH_REQUIRED' });
+                    }
+                    const { token, path: filePath, name } = (params ?? {});
+                    if (typeof token !== 'string' || !token || typeof filePath !== 'string' || !path.isAbsolute(filePath)) {
+                        throw new DinoxError('gateway.sendFile needs a session token and an absolute path', { code: 'USAGE_ERROR' });
+                    }
+                    const sent = await this.gateways.sendFile(token, {
+                        kind: 'path',
+                        path: filePath,
+                        ...(typeof name === 'string' && name.trim() ? { name: name.trim() } : {}),
+                    });
+                    return { id: req.id, ok: true, result: sent };
+                }
                 case 'thread.messages': {
                     if (!this.userId) {
                         throw new DinoxError('Reading conversations needs a signed-in daemon', { code: 'AUTH_REQUIRED' });

package/dist/daemon/supervise.d.ts

@@ -0,0 +1,29 @@
+import { type ChildProcess } from 'node:child_process';
+/** First restart delay after a crash; doubles per consecutive crash. */
+export declare const SUPERVISE_INITIAL_BACKOFF_MS = 1000;
+export declare const SUPERVISE_MAX_BACKOFF_MS = 60000;
+/** A daemon that ran this long counts as healthy, so the next crash restarts quickly again. */
+export declare const SUPERVISE_HEALTHY_RUN_MS = 60000;
+export type SupervisedExit = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+};
+export type SuperviseDependencies = {
+    startChild: () => ChildProcess;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    log: (message: string, details?: Record<string, unknown>) => void;
+    /** Registers a handler for a stop request (signal); the loop then stops the child and returns. */
+    onStopRequest: (handler: () => void) => void;
+};
+/**
+ * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
+ * and systemd's Restart=on-failure do: restarts it after a crash with an
+ * exponential backoff, and returns once it exits cleanly (exit code 0 from
+ * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
+ * or when asked to stop. Used where the service manager cannot restart the
+ * daemon itself (Windows Task Scheduler).
+ */
+export declare function superviseDaemon(deps: SuperviseDependencies): Promise<number>;
+/** Runs the supervisor for this CLI's daemon until it exits cleanly or is signalled. */
+export declare function superviseCurrentDaemon(port: number): Promise<number>;

package/dist/daemon/supervise.js

@@ -0,0 +1,98 @@
+import { spawn } from 'node:child_process';
+import { appendDaemonLogLine, closeDaemonLogFd, openDaemonLogForChild } from './log.js';
+/** First restart delay after a crash; doubles per consecutive crash. */
+export const SUPERVISE_INITIAL_BACKOFF_MS = 1_000;
+export const SUPERVISE_MAX_BACKOFF_MS = 60_000;
+/** A daemon that ran this long counts as healthy, so the next crash restarts quickly again. */
+export const SUPERVISE_HEALTHY_RUN_MS = 60_000;
+function waitForExit(child) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const settle = (exit) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(exit);
+        };
+        child.once('exit', (code, signal) => settle({ code, signal }));
+        // A child that cannot be spawned at all counts as a crash.
+        child.once('error', () => settle({ code: 1, signal: null }));
+    });
+}
+/**
+ * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
+ * and systemd's Restart=on-failure do: restarts it after a crash with an
+ * exponential backoff, and returns once it exits cleanly (exit code 0 from
+ * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
+ * or when asked to stop. Used where the service manager cannot restart the
+ * daemon itself (Windows Task Scheduler).
+ */
+export async function superviseDaemon(deps) {
+    let stopping = false;
+    let current = null;
+    let wakeSleep = null;
+    deps.onStopRequest(() => {
+        stopping = true;
+        current?.kill('SIGTERM');
+        wakeSleep?.();
+    });
+    let backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
+    while (!stopping) {
+        const startedAt = deps.now();
+        const child = deps.startChild();
+        current = child;
+        deps.log('daemon started', { pid: child.pid ?? null });
+        const exit = await waitForExit(child);
+        current = null;
+        if (stopping)
+            break;
+        if (exit.code === 0) {
+            deps.log('daemon exited cleanly; supervisor stopping');
+            return 0;
+        }
+        if (deps.now() - startedAt >= SUPERVISE_HEALTHY_RUN_MS)
+            backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
+        deps.log('daemon crashed; restarting', { code: exit.code, signal: exit.signal, delayMs: backoffMs });
+        await Promise.race([
+            deps.sleep(backoffMs),
+            new Promise((resolve) => {
+                wakeSleep = resolve;
+            }),
+        ]);
+        wakeSleep = null;
+        backoffMs = Math.min(backoffMs * 2, SUPERVISE_MAX_BACKOFF_MS);
+    }
+    deps.log('supervisor stopped on request');
+    return 0;
+}
+/** Runs the supervisor for this CLI's daemon until it exits cleanly or is signalled. */
+export async function superviseCurrentDaemon(port) {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        throw new Error('Cannot determine the CLI entrypoint for the daemon');
+    // Launched hidden at logon there is no console, so write to the log file directly.
+    const log = (message, details) => appendDaemonLogLine('dinox-supervisor', message, details);
+    return superviseDaemon({
+        startChild: () => {
+            const logFd = openDaemonLogForChild();
+            try {
+                return spawn(process.execPath, [...process.execArgv, entrypoint, 'daemon', 'start', '--port', String(port), '--no-detach'], 
+                // Same (already clean) environment, which carries the service marker.
+                { stdio: ['ignore', logFd, logFd], env: process.env, windowsHide: true });
+            }
+            finally {
+                closeDaemonLogFd(logFd);
+            }
+        },
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now(),
+        log,
+        onStopRequest: (handler) => {
+            for (const signal of ['SIGINT', 'SIGTERM', 'SIGBREAK']) {
+                process.on(signal, handler);
+            }
+            // Like the daemon, never stop on a hangup.
+            process.on('SIGHUP', () => undefined);
+        },
+    });
+}

package/dist/daemon/supervisor.d.ts

@@ -7,9 +7,11 @@
  *
  * Restart policy is "on failure" only: a clean exit (`dino daemon stop`, a
  * version/account restart, exclusive DB access for `doctor`) leaves it
- * stopped until the CLI starts it again through the manager.
+ * stopped until the CLI starts it again through the manager. launchd and
+ * systemd restart the daemon themselves; on Windows, Task Scheduler only
+ * starts `dino daemon supervise`, which restarts it (see supervise.ts).
  */
-export type DaemonServiceKind = 'launchd' | 'systemd';
+export type DaemonServiceKind = 'launchd' | 'systemd' | 'schtasks';
 export type DaemonServiceSpec = {
     program: string;
     args: string[];
@@ -29,6 +31,8 @@ export type DaemonService = {
     readonly definitionPath: string;
     render(spec: DaemonServiceSpec): string;
     isInstalled(): boolean;
+    /** True when the installed definition is exactly what this CLI would write. */
+    isCurrent(spec: DaemonServiceSpec): boolean;
     /** Writes the definition and (re)loads it, which starts the daemon. */
     install(spec: DaemonServiceSpec): Promise<void>;
     /** Starts the installed daemon when it is not running. */
@@ -44,16 +48,28 @@ export declare const runServiceCommand: ServiceCommandRunner;
  * non-default `DINOX_DATA_DIR` gets its own service.
  */
 export declare function daemonServiceLabel(env?: NodeJS.ProcessEnv): string;
-/** True when the installed definition differs from what this CLI would write. */
-export declare function serviceDefinitionIsStale(service: DaemonService, spec: DaemonServiceSpec): boolean;
 export declare function renderLaunchdPlist(label: string, spec: DaemonServiceSpec): string;
 export declare function renderSystemdUnit(spec: DaemonServiceSpec): string;
+/** Quotes one argument the way CommandLineToArgvW (and so Node) parses it back. */
+export declare function quoteWindowsArg(value: string): string;
+/**
+ * Task Scheduler runs console programs in a visible window, so the task runs
+ * this script with wscript, which sets the daemon environment and starts the
+ * supervisor with a hidden window (the launcher pattern pm2-windows-startup
+ * uses). The supervisor then outlives the script.
+ */
+export declare function renderWindowsLauncher(spec: DaemonServiceSpec): string;
+export declare function renderWindowsTaskXml(userId: string, wscriptPath: string, launcherPath: string): string;
 export type DaemonServiceOptions = {
     platform?: NodeJS.Platform;
     env?: NodeJS.ProcessEnv;
     homeDir?: string;
     uid?: number;
     run?: ServiceCommandRunner;
+    /** Windows: where the launcher script lives (the daemon directory). */
+    launcherDir?: string;
+    /** Windows: `DOMAIN\\user` the logon task runs as. */
+    windowsUserId?: string;
 };
-/** The service manager for this platform, or null where none is supported (Windows). */
+/** The service manager for this platform, or null where none is supported. */
 export declare function getDaemonService(options?: DaemonServiceOptions): DaemonService | null;