@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/daemon/pid.js

@@ -1,8 +1,15 @@
-import { homedir } from 'os';
-import { join } from 'path';
-import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from 'fs';
+import crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join } from 'node:path';
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { getDataDir } from '../config/paths.js';
+import { acquireExclusiveSqliteLease } from '../utils/sqliteLease.js';
+const DAEMON_START_LOCK_TIMEOUT_MS = 10_000;
+const LEGACY_DAEMON_UPTIME_TOLERANCE_MS = 60_000;
+const execFileAsync = promisify(execFile);
 export function getDaemonDir() {
-    return join(homedir(), '.dinox', 'daemon');
+    return join(getDataDir(), 'daemon');
 }
 export function getPidFilePath() {
     return join(getDaemonDir(), 'daemon.pid');
@@ -10,32 +17,91 @@ export function getPidFilePath() {
 export function getPortFilePath() {
     return join(getDaemonDir(), 'daemon.port');
 }
-export function savePid(pid, port) {
+export function getSocketFilePath() {
+    return join(getDaemonDir(), 'd.sock');
+}
+export function getDaemonSocketPath() {
+    if (process.platform === 'win32') {
+        const hash = crypto.createHash('sha256').update(getDataDir(), 'utf8').digest('hex').slice(0, 16);
+        return `\\\\.\\pipe\\dinox-cli-${hash}`;
+    }
+    return getSocketFilePath();
+}
+export function getTokenFilePath() {
+    return join(getDaemonDir(), 'daemon.token');
+}
+export function getStartLockFilePath() {
+    return join(getDaemonDir(), 'daemon.start.lock');
+}
+export function ensureDaemonDir() {
     const dir = getDaemonDir();
     if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch {
+        // Best effort: older filesystems may not support POSIX mode changes.
     }
-    writeFileSync(getPidFilePath(), String(pid));
-    writeFileSync(getPortFilePath(), String(port));
+    return dir;
+}
+export function savePid(pid, port, instanceId) {
+    ensureDaemonDir();
+    writeFileSync(getPidFilePath(), JSON.stringify({
+        pid,
+        port,
+        instanceId,
+        startedAt: new Date().toISOString(),
+    }), { mode: 0o600 });
+    writeFileSync(getPortFilePath(), String(port), { mode: 0o600 });
 }
 export function readPid() {
     try {
-        const pid = parseInt(readFileSync(getPidFilePath(), 'utf-8').trim());
-        const port = parseInt(readFileSync(getPortFilePath(), 'utf-8').trim());
+        const raw = readFileSync(getPidFilePath(), 'utf-8').trim();
+        let pid;
+        let port;
+        let instanceId = null;
+        let startedAt = null;
+        if (raw.startsWith('{')) {
+            const parsed = JSON.parse(raw);
+            pid = Number(parsed.pid);
+            port = Number(parsed.port);
+            instanceId = typeof parsed.instanceId === 'string' && parsed.instanceId.trim()
+                ? parsed.instanceId
+                : null;
+            startedAt = typeof parsed.startedAt === 'string' && parsed.startedAt.trim()
+                ? parsed.startedAt
+                : null;
+        }
+        else {
+            pid = parseInt(raw, 10);
+            port = parseInt(readFileSync(getPortFilePath(), 'utf-8').trim(), 10);
+        }
         if (!Number.isFinite(pid) || pid <= 0) {
             return null;
         }
         if (!Number.isFinite(port) || port < 1 || port > 65535) {
             return null;
         }
-        return { pid, port };
+        return { pid, port, instanceId, startedAt };
     }
     catch {
         return null;
     }
 }
-export function removePid() {
-    for (const path of [getPidFilePath(), getPortFilePath()]) {
+export function removePid(expectedInstanceId, options = {}) {
+    const current = readPid();
+    if (options.expectedPid !== undefined && current?.pid !== options.expectedPid) {
+        return false;
+    }
+    if (expectedInstanceId && !current && !options.allowMissingOwner) {
+        return false;
+    }
+    if (expectedInstanceId && current && current.instanceId !== expectedInstanceId) {
+        return false;
+    }
+    for (const path of [getPidFilePath(), getPortFilePath(), getTokenFilePath(), getSocketFilePath()]) {
         try {
             unlinkSync(path);
         }
@@ -43,6 +109,7 @@ export function removePid() {
             // Ignore missing files/stale paths.
         }
     }
+    return true;
 }
 export function isProcessRunning(pid) {
     try {
@@ -53,3 +120,70 @@ export function isProcessRunning(pid) {
         return false;
     }
 }
+function parseProcessElapsedMs(value) {
+    const trimmed = value.trim();
+    const match = trimmed.match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/);
+    if (!match) {
+        return null;
+    }
+    const days = Number(match[1] ?? 0);
+    const hours = Number(match[2] ?? 0);
+    const minutes = Number(match[3] ?? 0);
+    const seconds = Number(match[4] ?? 0);
+    if (![days, hours, minutes, seconds].every(Number.isFinite)) {
+        return null;
+    }
+    return (((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000;
+}
+function commandLooksLikeLegacyDaemon(command) {
+    return /(?:^|[\\/\s])dino(?:x)?(?:\.[cm]?[jt]s)?["']?\s+daemon\s+start(?:\s|$)/i.test(command)
+        && /(?:^|\s)--no-detach(?:\s|$)/.test(command);
+}
+export async function isLegacyDaemonProcess(pid, daemonUptimeMs) {
+    if (!Number.isInteger(pid) || pid <= 0 || !Number.isFinite(daemonUptimeMs) || daemonUptimeMs < 0) {
+        return false;
+    }
+    try {
+        if (process.platform === 'win32') {
+            const command = [
+                '$p = Get-CimInstance Win32_Process -Filter "ProcessId = ' + pid + '";',
+                'if ($null -ne $p) {',
+                '  [Console]::WriteLine($p.CreationDate.ToUniversalTime().ToString("o"));',
+                '  [Console]::Write($p.CommandLine);',
+                '}',
+            ].join(' ');
+            const { stdout } = await execFileAsync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', command], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+            const newline = stdout.indexOf('\n');
+            if (newline < 0) {
+                return false;
+            }
+            const createdAt = Date.parse(stdout.slice(0, newline).trim());
+            const processUptimeMs = Date.now() - createdAt;
+            return Number.isFinite(processUptimeMs)
+                && Math.abs(processUptimeMs - daemonUptimeMs) <= LEGACY_DAEMON_UPTIME_TOLERANCE_MS
+                && commandLooksLikeLegacyDaemon(stdout.slice(newline + 1).trim());
+        }
+        const { stdout } = await execFileAsync('ps', ['-ww', '-p', String(pid), '-o', 'etime=', '-o', 'command='], { encoding: 'utf8', timeout: 2_000, maxBuffer: 64 * 1024 });
+        const match = stdout.trim().match(/^(\S+)\s+([\s\S]+)$/);
+        if (!match) {
+            return false;
+        }
+        const processUptimeMs = parseProcessElapsedMs(match[1]);
+        return processUptimeMs !== null
+            && Math.abs(processUptimeMs - daemonUptimeMs) <= LEGACY_DAEMON_UPTIME_TOLERANCE_MS
+            && commandLooksLikeLegacyDaemon(match[2]);
+    }
+    catch {
+        return false;
+    }
+}
+export async function acquireDaemonStartLock(timeoutMs = DAEMON_START_LOCK_TIMEOUT_MS) {
+    ensureDaemonDir();
+    return acquireExclusiveSqliteLease({
+        lockPath: getStartLockFilePath(),
+        timeoutMs,
+        maxWaitMs: timeoutMs,
+        pollIntervalMs: 50,
+        createBusyError: () => new Error('Timed out waiting for daemon start lock'),
+    });
+}

package/dist/daemon/route.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Default online reads use the long-lived daemon as the canonical DB owner. The
+ * process-local path is only for explicit modes that require opening the cache here:
+ *  - `--offline`: must read the local cache directly without network sync.
+ *  - `--require-sync`: must run the in-process sync gate before reading.
+ * The local runtime coordinates with a same-database daemon through the shared
+ * lifecycle lock before opening SQLite.
+ */
+export declare function shouldUseDaemon(globals: Record<string, unknown>): boolean;
+/**
+ * Route a read through the daemon when allowed, otherwise run it locally. `daemonRun`
+ * receives a thin sender bound to the daemon; `localRun` opens its own db/sync path.
+ */
+export declare function routeRead<T>(globals: Record<string, unknown>, daemonMethod: string, daemonParams: unknown, localRun: () => Promise<T>): Promise<T>;

package/dist/daemon/route.js

@@ -0,0 +1,40 @@
+import { sendDaemonRequest } from './client.js';
+import { ensureDaemonRunning } from './ensure.js';
+import { DinoxError } from '../utils/errors.js';
+/**
+ * Default online reads use the long-lived daemon as the canonical DB owner. The
+ * process-local path is only for explicit modes that require opening the cache here:
+ *  - `--offline`: must read the local cache directly without network sync.
+ *  - `--require-sync`: must run the in-process sync gate before reading.
+ * The local runtime coordinates with a same-database daemon through the shared
+ * lifecycle lock before opening SQLite.
+ */
+export function shouldUseDaemon(globals) {
+    return !globals.offline && !globals.requireSync;
+}
+/**
+ * Route a read through the daemon when allowed, otherwise run it locally. `daemonRun`
+ * receives a thin sender bound to the daemon; `localRun` opens its own db/sync path.
+ */
+export async function routeRead(globals, daemonMethod, daemonParams, localRun) {
+    if (!shouldUseDaemon(globals)) {
+        return localRun();
+    }
+    try {
+        await ensureDaemonRunning();
+        return (await sendDaemonRequest(daemonMethod, daemonParams));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new DinoxError(`Daemon execution failed: ${message}`, {
+            code: 'DAEMON_UNAVAILABLE',
+            cause: error,
+            suggestion: 'Run `dino doctor --fix --format json` to repair local daemon state, or retry with `--offline` to use the local cache directly.',
+            suggestedAction: {
+                command: 'dino doctor --fix --format json',
+                reason: 'Default online reads require the daemon-owned database runtime.',
+            },
+            recoverable: true,
+        });
+    }
+}

package/dist/daemon/server.d.ts

@@ -3,8 +3,19 @@ export declare class DaemonServer {
     private db;
     private server;
     private startTime;
+    private readonly instanceId;
+    private readonly version;
+    private userId;
+    private tokenFingerprint;
+    private runtimeConfigFingerprint;
+    private port;
+    private ownsArtifacts;
+    private releaseOwner;
+    private stopPromise;
     initialize(): Promise<void>;
     handleRequest(req: DaemonRequest): Promise<DaemonResponse>;
+    private isCacheStale;
     start(port: number): Promise<void>;
     stop(): Promise<void>;
+    private stopInternal;
 }

package/dist/daemon/server.js

@@ -1,13 +1,20 @@
+import crypto from 'node:crypto';
 import { createServer } from 'http';
+import { chmodSync, existsSync } from 'node:fs';
 import { loadConfig } from '../config/store.js';
-import { resolveConfig } from '../config/resolve.js';
-import { connectPowerSync, waitForIdleDataFlow } from '../powersync/runtime.js';
-import { searchNotes, getNoteDetails } from '../commands/notes/repo.js';
+import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve.js';
+import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot, } from '../powersync/runtime.js';
+import { executeNoteSearch } from '../commands/notes/repo.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
-import { searchTodoTasks } from '../commands/todo/repo.js';
-import { savePid, removePid } from './pid.js';
+import { executeTodoSearch } from '../commands/todo/repo.js';
+import { ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
 import { getPackageVersion } from '../utils/version.js';
+import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
+import { buildStructuredErrorPayload, DinoxError } from '../utils/errors.js';
+import { getDaemonInfo } from './client.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
+const DAEMON_PROCESS_VERSION = getPackageVersion();
 async function readJsonBody(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
@@ -32,19 +39,52 @@ async function readJsonBody(req) {
         req.on('error', reject);
     });
 }
+function isJsonRequest(req) {
+    const contentType = req.headers['content-type'];
+    if (typeof contentType !== 'string') {
+        return false;
+    }
+    return contentType.split(';', 1)[0]?.trim().toLowerCase() === 'application/json';
+}
+function validateLocalRequest(req) {
+    if (req.headers.origin) {
+        return { ok: false, status: 403, message: 'Browser-origin daemon requests are not allowed' };
+    }
+    if (!isJsonRequest(req)) {
+        return { ok: false, status: 415, message: 'Daemon requests must use application/json' };
+    }
+    return { ok: true };
+}
 export class DaemonServer {
     db = null;
     server = null;
     startTime = Date.now();
+    instanceId = crypto.randomUUID();
+    version = DAEMON_PROCESS_VERSION;
+    userId = null;
+    tokenFingerprint = null;
+    runtimeConfigFingerprint = null;
+    port = null;
+    ownsArtifacts = false;
+    releaseOwner = null;
+    stopPromise = null;
     async initialize() {
-        const config = resolveConfig(await loadConfig());
-        const { db } = await connectPowerSync({ config, offline: false, timeoutMs: config.sync.timeoutMs });
+        const baseConfig = resolveConfig(await loadConfig());
+        const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs: baseConfig.sync.timeoutMs });
+        this.userId = config.auth.userId ?? null;
+        this.tokenFingerprint = config.auth.tokenFingerprint ?? null;
+        this.runtimeConfigFingerprint = fingerprintDaemonRuntimeConfig(config);
+        const { db, releaseOwner } = await connectPowerSync({
+            config,
+            offline: false,
+            timeoutMs: config.sync.timeoutMs,
+            waitForInitialSync: false,
+            expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
+        });
         this.db = db;
-        setInterval(async () => {
-            if (this.db) {
-                await waitForIdleDataFlow(this.db, 5000).catch(() => { });
-            }
-        }, 30000);
+        this.releaseOwner = releaseOwner;
+        // PowerSync keeps the local cache in sync continuously while connected,
+        // so no background polling loop is needed here.
     }
     async handleRequest(req) {
         try {
@@ -54,50 +94,92 @@ export class DaemonServer {
             const { method, params } = req;
             switch (method) {
                 case 'ping':
-                    return { id: req.id, ok: true, result: { uptime: Date.now() - this.startTime, version: getPackageVersion() } };
-                case 'note.search':
-                    const notes = await searchNotes(this.db, params.query || '', {
-                        includeDeleted: params.includeDeleted || false,
-                        tagsExpression: params.tags,
-                        createdAtFrom: params.from,
-                        createdAtTo: params.to,
-                    });
-                    return { id: req.id, ok: true, result: notes };
-                case 'note.get':
-                    const noteDetails = await getNoteDetails(this.db, [params.id]);
-                    return { id: req.id, ok: true, result: noteDetails[0] || null };
+                    return {
+                        id: req.id,
+                        ok: true,
+                        result: {
+                            pid: process.pid,
+                            instanceId: this.instanceId,
+                            uptime: Date.now() - this.startTime,
+                            version: this.version,
+                            transport: 'socket',
+                            socketPath: getDaemonSocketPath(),
+                            userId: this.userId,
+                            tokenFingerprint: this.tokenFingerprint,
+                            runtimeConfigFingerprint: this.runtimeConfigFingerprint,
+                            authenticated: Boolean(this.userId && this.tokenFingerprint),
+                        },
+                    };
+                case 'shutdown': {
+                    const shutdownParams = params;
+                    if (shutdownParams?.expectedInstanceId !== this.instanceId) {
+                        throw new DinoxError('Daemon instance changed before shutdown was received.', {
+                            code: 'DAEMON_INSTANCE_MISMATCH',
+                            recoverable: true,
+                            details: {
+                                expectedInstanceId: shutdownParams?.expectedInstanceId ?? null,
+                                actualInstanceId: this.instanceId,
+                            },
+                            suggestion: 'Ping the daemon again before retrying shutdown.',
+                        });
+                    }
+                    const timer = setTimeout(() => {
+                        void this.stop().catch(() => undefined);
+                    }, 10);
+                    timer.unref?.();
+                    return { id: req.id, ok: true, result: { stopping: true, instanceId: this.instanceId } };
+                }
+                case 'note.search': {
+                    // Same executor as the local `dino note search` path — no option/result drift.
+                    await syncNoteTokenIndex(this.db);
+                    const result = await executeNoteSearch(this.db, params);
+                    return { id: req.id, ok: true, result: { ...result, stale: this.isCacheStale() } };
+                }
                 case 'graph.backlinks':
                     const backlinks = await getBacklinks(this.db, params.id);
-                    return { id: req.id, ok: true, result: backlinks };
+                    return { id: req.id, ok: true, result: { ...backlinks, stale: this.isCacheStale() } };
                 case 'graph.outlinks':
                     const outlinks = await getOutlinks(this.db, params.id);
-                    return { id: req.id, ok: true, result: outlinks };
+                    return { id: req.id, ok: true, result: { ...outlinks, stale: this.isCacheStale() } };
                 case 'graph.related':
                     const related = await getRelatedNotes(this.db, params.id, params.depth || 2);
-                    return { id: req.id, ok: true, result: related };
+                    return { id: req.id, ok: true, result: { ...related, stale: this.isCacheStale() } };
                 case 'graph.stats':
                     const graphStats = await getGraphStats(this.db);
-                    return { id: req.id, ok: true, result: graphStats };
-                case 'todo.search':
-                    const todos = await searchTodoTasks(this.db, params.query || '', {
-                        includeDeleted: false,
-                        taskStatus: params.status || 'all',
-                        taskTagFilter: params.tags || [],
-                        limit: params.limit || 50,
-                        scanLimit: params.scanLimit || 200,
-                    });
-                    return { id: req.id, ok: true, result: todos };
+                    return { id: req.id, ok: true, result: { ...graphStats, stale: this.isCacheStale() } };
+                case 'todo.search': {
+                    // Same executor as the local `dino todo search` path — no option/result drift.
+                    const result = await executeTodoSearch(this.db, params);
+                    return { id: req.id, ok: true, result: { ...result, stale: this.isCacheStale() } };
+                }
                 default:
                     throw new Error(`Unknown method: ${method}`);
             }
         }
         catch (error) {
-            return { id: req.id, ok: false, error: error.message };
+            return { id: req.id, ok: false, error: buildStructuredErrorPayload(error, false) };
         }
     }
+    isCacheStale() {
+        if (!this.db) {
+            return true;
+        }
+        const status = getStatusSnapshot(this.db);
+        return (!status.connected ||
+            !status.hasSynced ||
+            status.dataFlowStatus.downloading ||
+            Boolean(status.dataFlowStatus.downloadError));
+    }
     async start(port) {
+        this.port = port;
         this.server = createServer(async (req, res) => {
             if (req.method === 'POST') {
+                const validation = validateLocalRequest(req);
+                if (!validation.ok) {
+                    res.writeHead(validation.status, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: validation.message }));
+                    return;
+                }
                 try {
                     const daemonReq = await readJsonBody(req);
                     const daemonRes = await this.handleRequest(daemonReq);
@@ -118,23 +200,92 @@ export class DaemonServer {
         });
         this.server.headersTimeout = 5_000;
         this.server.requestTimeout = 10_000;
-        await new Promise((resolve, reject) => {
+        try {
+            ensureDaemonDir();
+            const socketPath = getDaemonSocketPath();
+            if (process.platform !== 'win32' && existsSync(socketPath)) {
+                const existing = await getDaemonInfo();
+                if (existing) {
+                    throw new Error(`A daemon is already listening on ${socketPath}`);
+                }
+                const pidInfo = readPid();
+                if (!pidInfo?.instanceId || isProcessRunning(pidInfo.pid)) {
+                    throw new Error(`Daemon socket ${socketPath} exists but ownership cannot be proven stale`);
+                }
+                removePid();
+            }
+            await new Promise((resolve, reject) => {
+                if (!this.server) {
+                    reject(new Error('Server not initialized'));
+                    return;
+                }
+                this.server.once('error', reject);
+                this.server.listen(socketPath, () => resolve());
+            });
+            if (process.platform !== 'win32') {
+                try {
+                    chmodSync(socketPath, 0o600);
+                }
+                catch {
+                    // Best effort: not every filesystem honors socket chmod.
+                }
+            }
+            savePid(process.pid, port, this.instanceId);
+            this.ownsArtifacts = true;
+        }
+        catch (error) {
             if (!this.server) {
-                reject(new Error('Server not initialized'));
-                return;
+                throw error;
             }
-            this.server.once('error', reject);
-            this.server.listen(port, '127.0.0.1', () => resolve());
-        });
-        savePid(process.pid, port);
+            await new Promise((resolve) => this.server?.close(() => resolve())).catch(() => undefined);
+            this.server = null;
+            throw error;
+        }
     }
     async stop() {
-        if (this.server) {
-            await new Promise((resolve) => this.server?.close(() => resolve()));
+        if (this.stopPromise) {
+            return this.stopPromise;
+        }
+        const attempt = this.stopInternal();
+        this.stopPromise = attempt;
+        try {
+            await attempt;
+        }
+        finally {
+            if (this.stopPromise === attempt) {
+                this.stopPromise = null;
+            }
+        }
+    }
+    async stopInternal() {
+        const db = this.db;
+        const releaseOwner = this.releaseOwner;
+        if (db) {
+            if (releaseOwner) {
+                await closePowerSyncAndReleaseOwner(db, releaseOwner);
+            }
+            else {
+                await db.close();
+            }
+            if (this.db === db) {
+                this.db = null;
+            }
+            if (this.releaseOwner === releaseOwner) {
+                this.releaseOwner = null;
+            }
+        }
+        const server = this.server;
+        if (server) {
+            await new Promise((resolve, reject) => {
+                server.close((error) => error ? reject(error) : resolve());
+            });
+            if (this.server === server) {
+                this.server = null;
+            }
         }
-        if (this.db) {
-            await this.db.close().catch(() => { });
+        if (this.ownsArtifacts) {
+            removePid(this.instanceId, { allowMissingOwner: true });
+            this.ownsArtifacts = false;
         }
-        removePid();
     }
 }

package/dist/daemon/types.d.ts

@@ -1,3 +1,4 @@
+import type { StructuredErrorPayload } from '../utils/errors.js';
 export type DaemonRequest = {
     id: string;
     method: string;
@@ -7,13 +8,40 @@ export type DaemonResponse = {
     id: string;
     ok: boolean;
     result?: any;
-    error?: string;
+    error?: string | StructuredErrorPayload;
+};
+export type DaemonShutdownParams = {
+    expectedInstanceId: string;
+};
+export type DaemonShutdownResult = {
+    stopping: true;
+    instanceId: string;
 };
 export type DaemonStatus = {
     running: boolean;
     pid?: number;
     port?: number;
+    socketPath?: string;
+    transport?: 'socket';
     uptime?: number;
     version?: string;
 };
+/** Handshake payload returned by the daemon `ping` method. */
+export type DaemonPingResult = {
+    pid: number;
+    instanceId: string;
+    uptime: number;
+    version: string;
+    transport: 'socket';
+    socketPath: string;
+    /** Identity the daemon connected with; null when running unauthenticated. */
+    userId: string | null;
+    /** Non-secret fingerprint of the exact authorization token used by this daemon. */
+    tokenFingerprint: string | null;
+    /** Non-secret fingerprint of endpoints, upload paths, and sync runtime settings. */
+    runtimeConfigFingerprint: string | null;
+    /** True only for daemons using the current authenticated local protocol. */
+    authenticated: boolean;
+};
+/** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export declare const DEFAULT_DAEMON_PORT = 45678;

package/dist/daemon/types.js

@@ -1 +1,2 @@
+/** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export const DEFAULT_DAEMON_PORT = 45678;