@dinoxx/dinox-cli 2.4.0 → 2.6.0

package/dist/gateway/types.d.ts

@@ -3,10 +3,16 @@
  * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
  *
  * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
- * owns its conversation context (gateway-session mode): each turn sends only
- * the new user message, while Dinox keeps a display/sync copy of the transcript.
+ * owns its conversation context (gateway-session mode): each turn sends the new
+ * user message plus any transcript messages its session has not seen (another
+ * agent answered meanwhile), while Dinox keeps the synced copy of the transcript.
  */
 export type GatewayKind = 'acp' | 'echo';
+/**
+ * When the agent must ask before acting: `ask` every time, or `auto_read`
+ * (reading and searching run without asking; edits and commands still ask).
+ */
+export type GatewayApprovalMode = 'ask' | 'auto_read';
 /** Local-only gateway definition (never synced: it may carry commands and env). */
 export type GatewayDefinition = {
     /** Stable id; also the `c_robot.id` the app binds agents to. */
@@ -20,13 +26,22 @@ export type GatewayDefinition = {
     /** ACP: executable started over stdio, e.g. `hermes` with args `["acp"]`. */
     command?: string;
     args?: string[];
-    /** Working directory handed to the agent's sessions. */
+    /** Working directory for new agent sessions (each session keeps the one it started in). */
     cwd?: string;
+    /**
+     * Directory of sessions bound before sessions recorded their own: the
+     * default directory as it was when it was first changed.
+     */
+    previousCwd?: string;
     /** Extra environment for the agent process (secrets stay on this machine). */
     env?: Record<string, string>;
     enabled: boolean;
     /** Offer the read-only Dinox knowledge tools (MCP) to the agent; default true. */
     dinoxTools?: boolean;
+    /** Default `ask`. */
+    approval?: GatewayApprovalMode;
+    /** Stays online but refuses new turns, so the owner can resume it from the app. */
+    paused?: boolean;
     createdAt: string;
 };
 export type GatewayToolStatus = 'pending' | 'running' | 'completed' | 'failed';
@@ -82,7 +97,11 @@ export type GatewayStopReason = 'end_turn' | 'cancelled' | 'max_tokens' | 'refus
 export type GatewayTurnInput = {
     /** Agent session to continue; absent starts a new one. */
     sessionId: string | null;
+    /** Working directory of the session (a new one starts here; a continued one is loaded with it). */
+    cwd: string;
     prompt: string;
+    /** Prepended to the prompt when the turn starts a new session, e.g. the agent's instructions. */
+    sessionPreamble?: string;
     /** Attachments the user sent with this turn (trusted, https). */
     resources: Array<{
         uri: string;

package/dist/gateway/types.js

@@ -3,7 +3,8 @@
  * Claude Code, Codex, ... over ACP) as remote devices the Dinox app can drive.
  *
  * The app sees each gateway as one `dinox.remote-device.v2` device. The agent
- * owns its conversation context (gateway-session mode): each turn sends only
- * the new user message, while Dinox keeps a display/sync copy of the transcript.
+ * owns its conversation context (gateway-session mode): each turn sends the new
+ * user message plus any transcript messages its session has not seen (another
+ * agent answered meanwhile), while Dinox keeps the synced copy of the transcript.
  */
 export {};

package/dist/gateway/workspaceFolders.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Folders an agent may work in, chosen from the app. The rules keep a remote
+ * choice inside the owner's own files: an existing directory under the home
+ * directory, never the home directory itself, nothing hidden (`~/.ssh`) and
+ * nothing in `~/Library`. Not a security boundary on its own (an agent with a
+ * shell can still `cd`); it keeps a tap from pointing an agent somewhere wrong.
+ */
+export type WorkspaceFolderErrorCode = 'not_found' | 'not_allowed';
+export declare class WorkspaceFolderError extends Error {
+    readonly code: WorkspaceFolderErrorCode;
+    constructor(code: WorkspaceFolderErrorCode, message: string);
+}
+export type WorkspaceFolder = {
+    name: string;
+    path: string;
+    /** Has a `.git` entry: likely a project the user works on. */
+    isProject: boolean;
+};
+/** The folder an agent may work in, resolved to its real path. */
+export declare function resolveWorkspaceFolder(input: string, home?: string): Promise<string>;
+/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
+export declare function agentHomeFolder(agentName: string, home?: string): string;
+/** Creates the agent's own folder when missing; the only folder the app can create. */
+export declare function ensureAgentHomeFolder(agentName: string, home?: string): Promise<string>;
+/** The visible subfolders of a folder (the home folder included), for browsing. */
+export declare function listWorkspaceFolders(input: string | null | undefined, home?: string): Promise<{
+    path: string;
+    parent: string | null;
+    folders: WorkspaceFolder[];
+    truncated: boolean;
+}>;
+/** Folders worth offering first: the given candidates that exist and are allowed, deduplicated. */
+export declare function existingWorkspaceFolders(candidates: Array<string | null | undefined>, home?: string): Promise<WorkspaceFolder[]>;

package/dist/gateway/workspaceFolders.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+export class WorkspaceFolderError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'WorkspaceFolderError';
+    }
+}
+const MAX_FOLDERS = 200;
+/** Home-level folders that hold system data rather than the user's work. */
+const SYSTEM_FOLDERS = new Set(['Library', 'Applications']);
+const SKIPPED_FOLDERS = new Set(['node_modules']);
+const AGENT_HOME_PARENT = 'Dinox Agents';
+async function realHome(home) {
+    return fs.realpath(home).catch(() => path.resolve(home));
+}
+function expandHome(input, home) {
+    if (input === '~')
+        return home;
+    if (input.startsWith('~/'))
+        return path.join(home, input.slice(2));
+    return input;
+}
+/** Segments of `target` below `home`, or null when it is not inside it. */
+function segmentsBelow(home, target) {
+    const relative = path.relative(home, target);
+    if (relative === '')
+        return [];
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        return null;
+    return relative.split(path.sep);
+}
+function isAllowedBelowHome(segments) {
+    if (segments.some((segment) => segment.startsWith('.')))
+        return false;
+    return !SYSTEM_FOLDERS.has(segments[0] ?? '');
+}
+async function resolveDirectory(input, home) {
+    const expanded = expandHome(input.trim(), home);
+    if (!path.isAbsolute(expanded)) {
+        throw new WorkspaceFolderError('not_allowed', 'Folder must be an absolute path');
+    }
+    // Refused by its name whether or not it exists (`~/.ssh`), so the answer
+    // never depends on what this computer happens to have.
+    const named = segmentsBelow(path.resolve(home), path.resolve(expanded));
+    if (named !== null && !isAllowedBelowHome(named)) {
+        throw new WorkspaceFolderError('not_allowed', 'This folder cannot be used');
+    }
+    let real;
+    try {
+        real = await fs.realpath(expanded);
+    }
+    catch {
+        throw new WorkspaceFolderError('not_found', 'Folder does not exist');
+    }
+    const stat = await fs.stat(real);
+    if (!stat.isDirectory())
+        throw new WorkspaceFolderError('not_found', 'Not a folder');
+    const segments = segmentsBelow(await realHome(home), real);
+    if (segments === null || !isAllowedBelowHome(segments)) {
+        throw new WorkspaceFolderError('not_allowed', 'This folder cannot be used');
+    }
+    return { real, segments };
+}
+/** The folder an agent may work in, resolved to its real path. */
+export async function resolveWorkspaceFolder(input, home = os.homedir()) {
+    const { real, segments } = await resolveDirectory(input, home);
+    if (segments.length === 0) {
+        throw new WorkspaceFolderError('not_allowed', 'Choose a folder inside your home folder');
+    }
+    return real;
+}
+/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
+export function agentHomeFolder(agentName, home = os.homedir()) {
+    const safeName = agentName.replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '').trim() || 'Agent';
+    return path.join(home, AGENT_HOME_PARENT, safeName.slice(0, 64));
+}
+/** Creates the agent's own folder when missing; the only folder the app can create. */
+export async function ensureAgentHomeFolder(agentName, home = os.homedir()) {
+    const folder = agentHomeFolder(agentName, home);
+    await fs.mkdir(folder, { recursive: true, mode: 0o755 });
+    return resolveWorkspaceFolder(folder, home);
+}
+async function hasGit(folder) {
+    return fs
+        .access(path.join(folder, '.git'))
+        .then(() => true)
+        .catch(() => false);
+}
+/** The visible subfolders of a folder (the home folder included), for browsing. */
+export async function listWorkspaceFolders(input, home = os.homedir()) {
+    const { real, segments } = await resolveDirectory(input?.trim() || home, home);
+    const entries = await fs.readdir(real, { withFileTypes: true });
+    const names = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => !name.startsWith('.') && !SKIPPED_FOLDERS.has(name))
+        .filter((name) => segments.length > 0 || !SYSTEM_FOLDERS.has(name))
+        .sort((a, b) => a.localeCompare(b));
+    const shown = names.slice(0, MAX_FOLDERS);
+    const folders = await Promise.all(shown.map(async (name) => {
+        const folder = path.join(real, name);
+        return { name, path: folder, isProject: await hasGit(folder) };
+    }));
+    return {
+        path: real,
+        parent: segments.length === 0 ? null : path.dirname(real),
+        folders,
+        truncated: names.length > shown.length,
+    };
+}
+/** Folders worth offering first: the given candidates that exist and are allowed, deduplicated. */
+export async function existingWorkspaceFolders(candidates, home = os.homedir()) {
+    const seen = new Set();
+    const folders = [];
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const folder = await resolveWorkspaceFolder(candidate, home).catch(() => null);
+        if (!folder || seen.has(folder))
+            continue;
+        seen.add(folder);
+        folders.push({ name: path.basename(folder), path: folder, isProject: await hasGit(folder) });
+    }
+    return folders;
+}

package/dist/utils/errorCodes.d.ts

@@ -63,6 +63,14 @@ export declare const ERROR_CODES: {
         readonly exitCode: 1;
         readonly description: "The daemon did not release database ownership in time.";
     };
+    readonly DAEMON_SERVICE_FAILED: {
+        readonly exitCode: 1;
+        readonly description: "The service manager (launchd / systemd) rejected a daemon service operation.";
+    };
+    readonly DAEMON_SERVICE_UNSUPPORTED: {
+        readonly exitCode: 5;
+        readonly description: "The daemon cannot run as a login service on this platform or with this auth setup.";
+    };
     readonly DAEMON_STALE: {
         readonly exitCode: 5;
         readonly description: "The daemon state is stale and needs a restart.";

package/dist/utils/errorCodes.js

@@ -21,6 +21,8 @@ export const ERROR_CODES = {
     DAEMON_LEGACY_UNVERIFIED: { exitCode: 1, description: 'A daemon from an older CLI could not be verified safely.' },
     DAEMON_RELEASE_FAILED: { exitCode: 1, description: 'The daemon could not release database ownership.' },
     DAEMON_RELEASE_TIMEOUT: { exitCode: 1, description: 'The daemon did not release database ownership in time.' },
+    DAEMON_SERVICE_FAILED: { exitCode: 1, description: 'The service manager (launchd / systemd) rejected a daemon service operation.' },
+    DAEMON_SERVICE_UNSUPPORTED: { exitCode: 5, description: 'The daemon cannot run as a login service on this platform or with this auth setup.' },
     DAEMON_STALE: { exitCode: 5, description: 'The daemon state is stale and needs a restart.' },
     DAEMON_START_FAILED: { exitCode: 5, description: 'The daemon process failed to start.' },
     DAEMON_START_TIMEOUT: { exitCode: 1, description: 'The daemon did not become ready in time.' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {