@jini-ai/daemon 0.3.8 → 0.5.1

package/dist/http/host-tools.d.ts

@@ -0,0 +1,214 @@
+/**
+ * @module host-tools
+ *
+ * Generic "open a working directory in a local host tool" surface, ported
+ * from the routes-classification table's `host-tools.ts` MIXED row (see
+ * `archived provenance ledger`): the editor catalogue, `$PATH`/mac-bundle probing, and
+ * guarded detached-spawn machinery have zero OD dependency and are ported
+ * here in full. `GET /api/editors` (which uses solely this machinery) was
+ * mounted first; `POST /api/resources/:resourceRef/open-in` (OD's `POST
+ * /api/projects/:id/open-in`) is now ported too, now that a generic
+ * workspace-root port exists (`workspace-root.ts`) to stand in for OD's
+ * `projectStore.getProject`/`projectFiles.resolveProjectDir` — see that
+ * route's own doc below for the exact mapping.
+ *
+ * The probing functions take an injectable `HostToolProbeEnv` (filesystem
+ * `access`, `env`, `platform`) rather than reading `process.env`/`fs`
+ * directly, so every platform/found/missing branch is exercisable from a
+ * single-OS test runner without touching the real filesystem.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import type { Express } from 'express';
+import { type AdapterContext } from '@jini-ai/http-kit';
+import { type WorkspaceRootResolver } from './workspace-root.js';
+export type RealPlatform = 'darwin' | 'win32' | 'linux';
+export type Platform = RealPlatform | 'unknown';
+export interface CatalogueEntry {
+    readonly id: string;
+    readonly label: string;
+    readonly icon: string;
+    /** CLI shim name to probe on `$PATH`. Mutually exclusive in practice with `macOpenBundle`, though both may be set as a fallback pair. */
+    readonly command?: string;
+    readonly commandArgs?: ({ workingDir }: {
+        workingDir: string;
+    }) => string[];
+    /** macOS-only fallback: when the CLI shim is missing, look for an app bundle by name and launch it via `open -a "<name>"`. */
+    readonly macOpenBundle?: string | readonly string[];
+    readonly macOpenArgs?: ({ bundleName, workingDir }: {
+        bundleName: string;
+        workingDir: string;
+    }) => string[];
+    readonly platforms?: readonly RealPlatform[];
+    readonly excludedPlatforms?: readonly RealPlatform[];
+}
+/** The cross-platform-staple + macOS-bundle editor/tool catalogue, unchanged from the origin. */
+export declare const CATALOGUE: readonly CatalogueEntry[];
+/** Maps Node's `process.platform` to this module's tri-state `Platform`; anything else (aix, freebsd, sunos, ...) is `'unknown'`. */
+export declare function currentPlatform(_required: Record<string, never>, { nodePlatform }?: {
+    readonly nodePlatform?: NodeJS.Platform | undefined;
+}): Platform;
+export declare function applicableForPlatform({ entry, platform }: {
+    readonly entry: CatalogueEntry;
+    readonly platform: Platform;
+}, _optional?: Record<string, never>): boolean;
+/**
+ * Everything the probing functions below need from the outside world, gathered into one
+ * injectable value. Production code gets {@link defaultProbeEnv}; tests inject a fake `access`
+ * (so "found"/"missing" is a table, not a real filesystem) and any `platform`/`env` they want to
+ * exercise, independent of the OS actually running the test.
+ */
+export interface HostToolProbeEnv {
+    readonly access: ({ path, mode }: {
+        path: string;
+        mode: number;
+    }) => Promise<void>;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: Platform;
+}
+export declare function defaultProbeEnv(_required: Record<string, never>, _optional?: Record<string, never>): HostToolProbeEnv;
+/**
+ * `$PATH` directories to probe, plus the common macOS/Linux locations a login shell would have
+ * that a GUI-launched daemon's thin inherited `PATH` often lacks (no `/usr/local/bin`, no
+ * `/opt/homebrew/bin`) — without these, CLI shims installed via an editor's "Install command"
+ * action are invisible to a daemon launched by double-clicking an app bundle.
+ */
+export declare function pathDirs(probeEnv: HostToolProbeEnv): string[];
+export declare function probeCommandOnPath({ command, probeEnv }: {
+    readonly command: string;
+    readonly probeEnv: HostToolProbeEnv;
+}, _optional?: Record<string, never>): Promise<string | null>;
+export declare function probeMacBundle({ name, probeEnv }: {
+    readonly name: string | readonly string[];
+    readonly probeEnv: HostToolProbeEnv;
+}, _optional?: Record<string, never>): Promise<{
+    name: string;
+    path: string;
+} | null>;
+/**
+ * A discriminated union rather than one shape with optional fields: `resolvedPath`/`launch` are
+ * only ever set together (both "found" branches below set the pair; the "not found" branch sets
+ * neither), so the type says that directly instead of leaving `resolvedPath` reachable-but-absent
+ * when `available` is `false`.
+ */
+type ResolvedEntry = {
+    readonly available: true;
+    readonly resolvedPath: string;
+    readonly launch: {
+        readonly command: string;
+        readonly argsForDir: (requiredArgs: {
+            readonly workingDir: string;
+        }) => string[];
+    };
+} | {
+    readonly available: false;
+};
+export declare function resolveEntry({ entry }: {
+    readonly entry: CatalogueEntry;
+}, { probeEnv }?: {
+    readonly probeEnv?: HostToolProbeEnv | undefined;
+}): Promise<ResolvedEntry>;
+export interface HostToolLaunchPlan {
+    readonly available: boolean;
+    readonly resolvedPath?: string;
+    readonly command?: string;
+    readonly args?: string[];
+}
+/** Resolves the concrete `{command, args}` a caller would spawn to open `workingDir` in `editorId`, or `available: false` if that tool isn't installed/known. */
+export declare function resolveHostToolLaunchPlan({ editorId, workingDir }: {
+    readonly editorId: string;
+    readonly workingDir: string;
+}, { probeEnv }?: {
+    readonly probeEnv?: HostToolProbeEnv | undefined;
+}): Promise<HostToolLaunchPlan>;
+export type LaunchHostToolResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/**
+ * Spawns a detached host-tool launch and waits for the OS to confirm it actually started. Node
+ * emits `'spawn'` once the child is running and `'error'` when the launch is refused (missing
+ * binary, quarantine, EACCES) — `'error'` arrives on a later tick, so this must be awaited before
+ * a caller replies, otherwise a launch the OS rejected would be reported as success (origin's
+ * #3871).
+ *
+ * Deliberately never passes `shell: true`: on Windows that would route the launch through
+ * `cmd.exe`, which shell-interprets args — and one of them is a caller-supplied directory path,
+ * so a path containing `&`/`|`/`^`/`>` etc. would inject commands. `command` is already resolved
+ * to an absolute path (including `.exe`/`.cmd`), so it's routed through `createCommandInvocation`
+ * (`@jini-ai/platform`), which runs a `.cmd`/`.bat` via `cmd.exe` with
+ * `CommandLineToArgvW`-safe verbatim args and everything else directly — no shell, no
+ * metacharacter interpretation.
+ */
+export declare function launchHostTool({ command, args }: {
+    readonly command: string;
+    readonly args: string[];
+}, { spawnImpl }?: {
+    readonly spawnImpl?: typeof nodeSpawn | undefined;
+}): Promise<LaunchHostToolResult>;
+export interface HostEditor {
+    readonly id: string;
+    readonly label: string;
+    readonly icon: string;
+    readonly available: boolean;
+    readonly resolvedPath?: string;
+    readonly platforms?: readonly RealPlatform[];
+}
+export interface HostEditorsResponse {
+    readonly editors: readonly HostEditor[];
+    readonly platform: Platform;
+}
+/** Probes every catalogue entry applicable to the current platform and reports which are actually installed. */
+export declare function listAvailableEditors(_required: Record<string, never>, { probeEnv }?: {
+    readonly probeEnv?: HostToolProbeEnv | undefined;
+}): Promise<HostEditorsResponse>;
+/** `GET /api/editors` — lists the host-tool catalogue applicable to this platform with live availability. */
+export declare const hostEditorsRoute: import("@jini-ai/http-kit").JsonRouteSpec<void, HostEditorsResponse, Record<string, never>>;
+export interface OpenResourceInEditorRequest {
+    readonly resourceRef: string;
+    readonly editorId: string;
+    readonly detail?: string;
+}
+export interface OpenResourceInEditorResponse {
+    readonly ok: true;
+    readonly editorId: string;
+    readonly path: string;
+}
+/** Everything `POST /api/resources/:resourceRef/open-in` needs from the host. */
+export interface HostToolsOpenInDeps {
+    /** Resolves a resource reference to a filesystem working directory. Defaults to {@link denyAllWorkspaceRoots} — a host that never wires a real resolver gets a 404 on every call, never a guessed path (see `workspace-root.ts`). */
+    readonly resolveRoot?: WorkspaceRootResolver;
+    readonly probeEnv?: HostToolProbeEnv;
+    readonly spawnImpl?: typeof nodeSpawn;
+}
+/**
+ * `POST /api/resources/:resourceRef/open-in` — launches `editorId` (from
+ * {@link CATALOGUE}) rooted at the working directory `deps.resolveRoot`
+ * resolves for `resourceRef`. Ported from OD's `POST
+ * /api/projects/:id/open-in`: `projectId` generalizes to the opaque
+ * `resourceRef` this package already uses (`active-context.ts`,
+ * `cancel-owned-runs.ts`), and `getProject`/`resolveProjectDir` generalize
+ * to the injected {@link WorkspaceRootResolver}. `PROJECT_NOT_FOUND` (an
+ * OD-product-only code with no `@jini-ai/protocol` equivalent — see
+ * `response.ts`'s file-map note) becomes a generic `NOT_FOUND` when the
+ * resolver denies. `EDITOR_NOT_AVAILABLE` (OD's 409 for "installed catalogue
+ * entry, but not found on this machine") becomes `CONFLICT`, which already
+ * maps to 409 in this package's `ERROR_STATUS_BY_CODE`.
+ *
+ * The launch-failure message is returned to the caller verbatim (unlike
+ * `runs.ts`'s SEC-005 redaction of internal agent-run errors): this is a
+ * same-origin, explicitly-consented, single local action the caller just
+ * asked for (open the tool it named, at the directory it's authorized to
+ * open) — the underlying spawn error (e.g. a quarantined/missing binary) is
+ * operationally useful to the caller and does not cross a trust boundary
+ * the way an internal agent-run exception can.
+ */
+export declare const openResourceInEditorRoute: import("@jini-ai/http-kit").JsonRouteSpec<OpenResourceInEditorRequest, OpenResourceInEditorResponse, HostToolsOpenInDeps>;
+/** Mounts `GET /api/editors` and `POST /api/resources/:resourceRef/open-in` on `app`. A pack's `http(app, services)` calls this directly. */
+export declare function registerHostToolsRoutes({ app, adapter }: {
+    readonly app: Express;
+    readonly adapter: AdapterContext;
+}, openInDeps?: HostToolsOpenInDeps): void;
+export {};
+//# sourceMappingURL=host-tools.d.ts.map

package/dist/http/host-tools.js

@@ -0,0 +1,329 @@
+/**
+ * @module host-tools
+ *
+ * Generic "open a working directory in a local host tool" surface, ported
+ * from the routes-classification table's `host-tools.ts` MIXED row (see
+ * `archived provenance ledger`): the editor catalogue, `$PATH`/mac-bundle probing, and
+ * guarded detached-spawn machinery have zero OD dependency and are ported
+ * here in full. `GET /api/editors` (which uses solely this machinery) was
+ * mounted first; `POST /api/resources/:resourceRef/open-in` (OD's `POST
+ * /api/projects/:id/open-in`) is now ported too, now that a generic
+ * workspace-root port exists (`workspace-root.ts`) to stand in for OD's
+ * `projectStore.getProject`/`projectFiles.resolveProjectDir` — see that
+ * route's own doc below for the exact mapping.
+ *
+ * The probing functions take an injectable `HostToolProbeEnv` (filesystem
+ * `access`, `env`, `platform`) rather than reading `process.env`/`fs`
+ * directly, so every platform/found/missing branch is exercisable from a
+ * single-OS test runner without touching the real filesystem.
+ */
+import { spawn as nodeSpawn } from 'node:child_process';
+import { access as fsAccess, constants as fsConstants } from 'node:fs/promises';
+import { createCommandInvocation } from '@jini-ai/platform';
+import { createApiError } from '@jini-ai/protocol';
+import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
+import { validationError } from '@jini-ai/http-kit';
+import { err, ok } from '@jini-ai/http-kit';
+import { denyAllWorkspaceRoots, resolveWorkspaceRoot, WorkspaceRootDeniedError } from './workspace-root.js';
+const MAC_OPEN_COMMAND = '/usr/bin/open';
+/** The cross-platform-staple + macOS-bundle editor/tool catalogue, unchanged from the origin. */
+export const CATALOGUE = [
+    { id: 'cursor', label: 'Cursor', icon: 'sparkles', command: 'cursor', macOpenBundle: 'Cursor' },
+    { id: 'vscode', label: 'VS Code', icon: 'file-code', command: 'code', macOpenBundle: 'Visual Studio Code' },
+    { id: 'windsurf', label: 'Windsurf', icon: 'sparkles', command: 'windsurf', macOpenBundle: 'Windsurf' },
+    { id: 'zed', label: 'Zed', icon: 'edit', command: 'zed', macOpenBundle: 'Zed' },
+    { id: 'qoder', label: 'Qoder', icon: 'sparkles', command: 'qoder', macOpenBundle: ['Qoder', 'QoderWork'] },
+    { id: 'antigravity', label: 'Antigravity', icon: 'orbit', command: 'antigravity', macOpenBundle: ['Antigravity', 'Google Antigravity'] },
+    { id: 'webstorm', label: 'WebStorm', icon: 'edit', command: 'webstorm', macOpenBundle: 'WebStorm' },
+    { id: 'idea', label: 'IntelliJ IDEA', icon: 'edit', command: 'idea', macOpenBundle: 'IntelliJ IDEA' },
+    { id: 'xcode', label: 'Xcode', icon: 'file-code', macOpenBundle: ['Xcode', 'Xcode-beta', 'Xcode Beta'], platforms: ['darwin'] },
+    { id: 'finder', label: 'Finder', icon: 'folder', command: MAC_OPEN_COMMAND, commandArgs: ({ workingDir }) => ['-R', workingDir], platforms: ['darwin'] },
+    { id: 'explorer', label: 'Explorer', icon: 'folder', command: 'explorer', platforms: ['win32'] },
+    { id: 'file-manager', label: 'File Manager', icon: 'folder', command: 'xdg-open', platforms: ['linux'] },
+    { id: 'terminal', label: 'Terminal', icon: 'sliders', macOpenBundle: 'Terminal', platforms: ['darwin'] },
+    // darwin-only: Warp cold-starts ignore the cwd argument on win32/linux, so the
+    // "open in Warp" UX is broken on those platforms (origin's #4544).
+    { id: 'warp', label: 'Warp', icon: 'sliders', macOpenBundle: 'Warp', platforms: ['darwin'] },
+];
+/** Maps Node's `process.platform` to this module's tri-state `Platform`; anything else (aix, freebsd, sunos, ...) is `'unknown'`. */
+export function currentPlatform(_required, { nodePlatform = process.platform } = {}) {
+    switch (nodePlatform) {
+        case 'darwin':
+            return 'darwin';
+        case 'win32':
+            return 'win32';
+        case 'linux':
+            return 'linux';
+        default:
+            return 'unknown';
+    }
+}
+export function applicableForPlatform({ entry, platform }, _optional = {}) {
+    if (platform === 'unknown')
+        return false;
+    if (entry.platforms && !entry.platforms.includes(platform))
+        return false;
+    if (entry.excludedPlatforms && entry.excludedPlatforms.includes(platform))
+        return false;
+    return true;
+}
+export function defaultProbeEnv(_required, _optional = {}) {
+    return { access: ({ path, mode }) => fsAccess(path, mode), env: process.env, platform: currentPlatform({}) };
+}
+/**
+ * `$PATH` directories to probe, plus the common macOS/Linux locations a login shell would have
+ * that a GUI-launched daemon's thin inherited `PATH` often lacks (no `/usr/local/bin`, no
+ * `/opt/homebrew/bin`) — without these, CLI shims installed via an editor's "Install command"
+ * action are invisible to a daemon launched by double-clicking an app bundle.
+ */
+export function pathDirs(probeEnv) {
+    const raw = probeEnv.env.PATH ?? '';
+    const sep = probeEnv.platform === 'win32' ? ';' : ':';
+    const home = probeEnv.env.HOME ?? '';
+    const extras = probeEnv.platform === 'darwin'
+        ? ['/usr/local/bin', '/opt/homebrew/bin', '/usr/bin', '/bin', '/usr/sbin', '/sbin', `${home}/.local/bin`]
+        : probeEnv.platform === 'linux'
+            ? ['/usr/local/bin', '/usr/bin', '/bin', `${home}/.local/bin`]
+            : [];
+    return [...raw.split(sep), ...extras].filter((dir) => dir.length > 0);
+}
+export async function probeCommandOnPath({ command, probeEnv }, _optional = {}) {
+    if (command.includes('/')) {
+        try {
+            await probeEnv.access({ path: command, mode: fsConstants.X_OK });
+            return command;
+        }
+        catch {
+            return null;
+        }
+    }
+    const dirs = pathDirs(probeEnv);
+    const suffixes = probeEnv.platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    for (const dir of dirs) {
+        for (const suffix of suffixes) {
+            const candidate = `${dir}/${command}${suffix}`;
+            try {
+                await probeEnv.access({ path: candidate, mode: fsConstants.X_OK });
+                return candidate;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return null;
+}
+async function resolveMacOpenCommand(probeEnv) {
+    try {
+        await probeEnv.access({ path: MAC_OPEN_COMMAND, mode: fsConstants.X_OK });
+        return MAC_OPEN_COMMAND;
+    }
+    catch {
+        return (await probeCommandOnPath({ command: 'open', probeEnv })) ?? MAC_OPEN_COMMAND;
+    }
+}
+export async function probeMacBundle({ name, probeEnv }, _optional = {}) {
+    if (probeEnv.platform !== 'darwin')
+        return null;
+    const names = Array.isArray(name) ? name : [name];
+    const home = probeEnv.env.HOME ?? '';
+    const candidates = [
+        (bundleName) => `/Applications/${bundleName}.app`,
+        (bundleName) => `${home}/Applications/${bundleName}.app`,
+        (bundleName) => `/System/Applications/${bundleName}.app`,
+        (bundleName) => `/System/Applications/Utilities/${bundleName}.app`,
+        (bundleName) => `/System/Library/CoreServices/${bundleName}.app`,
+    ];
+    for (const bundleName of names) {
+        for (const candidate of candidates) {
+            const path = candidate(bundleName);
+            try {
+                await probeEnv.access({ path, mode: fsConstants.R_OK });
+                return { name: bundleName, path };
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return null;
+}
+export async function resolveEntry({ entry }, { probeEnv = defaultProbeEnv({}) } = {}) {
+    if (entry.command) {
+        const resolved = await probeCommandOnPath({ command: entry.command, probeEnv });
+        if (resolved) {
+            return {
+                available: true,
+                resolvedPath: resolved,
+                launch: { command: resolved, argsForDir: entry.commandArgs ? ({ workingDir }) => entry.commandArgs({ workingDir }) : ({ workingDir }) => [workingDir] },
+            };
+        }
+    }
+    if (entry.macOpenBundle && probeEnv.platform === 'darwin') {
+        const bundle = await probeMacBundle({ name: entry.macOpenBundle, probeEnv });
+        if (bundle) {
+            return {
+                available: true,
+                resolvedPath: bundle.path,
+                launch: {
+                    command: await resolveMacOpenCommand(probeEnv),
+                    argsForDir: entry.macOpenArgs
+                        ? ({ workingDir }) => entry.macOpenArgs({ bundleName: bundle.name, workingDir })
+                        : ({ workingDir }) => ['-a', bundle.name, workingDir],
+                },
+            };
+        }
+    }
+    return { available: false };
+}
+/** Resolves the concrete `{command, args}` a caller would spawn to open `workingDir` in `editorId`, or `available: false` if that tool isn't installed/known. */
+export async function resolveHostToolLaunchPlan({ editorId, workingDir }, { probeEnv = defaultProbeEnv({}) } = {}) {
+    const entry = CATALOGUE.find((c) => c.id === editorId);
+    if (!entry)
+        return { available: false };
+    const probe = await resolveEntry({ entry }, { probeEnv });
+    if (!probe.available)
+        return { available: false };
+    return {
+        available: true,
+        resolvedPath: probe.resolvedPath,
+        command: probe.launch.command,
+        args: probe.launch.argsForDir({ workingDir }),
+    };
+}
+/**
+ * Spawns a detached host-tool launch and waits for the OS to confirm it actually started. Node
+ * emits `'spawn'` once the child is running and `'error'` when the launch is refused (missing
+ * binary, quarantine, EACCES) — `'error'` arrives on a later tick, so this must be awaited before
+ * a caller replies, otherwise a launch the OS rejected would be reported as success (origin's
+ * #3871).
+ *
+ * Deliberately never passes `shell: true`: on Windows that would route the launch through
+ * `cmd.exe`, which shell-interprets args — and one of them is a caller-supplied directory path,
+ * so a path containing `&`/`|`/`^`/`>` etc. would inject commands. `command` is already resolved
+ * to an absolute path (including `.exe`/`.cmd`), so it's routed through `createCommandInvocation`
+ * (`@jini-ai/platform`), which runs a `.cmd`/`.bat` via `cmd.exe` with
+ * `CommandLineToArgvW`-safe verbatim args and everything else directly — no shell, no
+ * metacharacter interpretation.
+ */
+export function launchHostTool({ command, args }, { spawnImpl = nodeSpawn } = {}) {
+    return new Promise((resolve) => {
+        const invocation = createCommandInvocation({ command, args });
+        const child = spawnImpl(invocation.command, invocation.args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: process.platform === 'win32',
+            windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        });
+        let settled = false;
+        child.once('spawn', () => {
+            if (settled)
+                return;
+            settled = true;
+            child.unref();
+            resolve({ ok: true });
+        });
+        child.once('error', (spawnError) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ ok: false, error: spawnError instanceof Error ? spawnError.message : String(spawnError) });
+        });
+    });
+}
+/** Probes every catalogue entry applicable to the current platform and reports which are actually installed. */
+export async function listAvailableEditors(_required, { probeEnv = defaultProbeEnv({}) } = {}) {
+    const filtered = CATALOGUE.filter((entry) => applicableForPlatform({ entry, platform: probeEnv.platform }));
+    const editors = await Promise.all(filtered.map(async (entry) => {
+        const probe = await resolveEntry({ entry }, { probeEnv });
+        return {
+            id: entry.id,
+            label: entry.label,
+            icon: entry.icon,
+            available: probe.available,
+            ...(probe.available ? { resolvedPath: probe.resolvedPath } : {}),
+            ...(entry.platforms ? { platforms: entry.platforms } : {}),
+        };
+    }));
+    return { editors, platform: probeEnv.platform };
+}
+/** `GET /api/editors` — lists the host-tool catalogue applicable to this platform with live availability. */
+export const hostEditorsRoute = defineJsonRoute({ method: 'get', path: '/api/editors', parse: () => ok({ value: undefined }), handle: async () => ok({ value: await listAvailableEditors({}) }) });
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseOpenResourceInEditor(input) {
+    const resourceRef = input.params.resourceRef;
+    if (typeof resourceRef !== 'string' || resourceRef.length === 0) {
+        return err({ error: validationError({ message: 'resourceRef must be a non-empty path parameter' }) });
+    }
+    if (!isRecord(input.body))
+        return err({ error: validationError({ message: 'body must be a JSON object' }) });
+    const editorId = input.body.editorId;
+    if (typeof editorId !== 'string' || editorId.length === 0) {
+        return err({ error: validationError({ message: 'editorId is required' }, { issues: [{ path: 'editorId', message: 'required non-empty string' }] }) });
+    }
+    const detail = input.body.detail;
+    if (detail !== undefined && (typeof detail !== 'string' || detail.length === 0)) {
+        return err({ error: validationError({ message: 'detail must be a non-empty string when provided' }) });
+    }
+    return ok({ value: { resourceRef, editorId, ...(detail === undefined ? {} : { detail }) } });
+}
+/**
+ * `POST /api/resources/:resourceRef/open-in` — launches `editorId` (from
+ * {@link CATALOGUE}) rooted at the working directory `deps.resolveRoot`
+ * resolves for `resourceRef`. Ported from OD's `POST
+ * /api/projects/:id/open-in`: `projectId` generalizes to the opaque
+ * `resourceRef` this package already uses (`active-context.ts`,
+ * `cancel-owned-runs.ts`), and `getProject`/`resolveProjectDir` generalize
+ * to the injected {@link WorkspaceRootResolver}. `PROJECT_NOT_FOUND` (an
+ * OD-product-only code with no `@jini-ai/protocol` equivalent — see
+ * `response.ts`'s file-map note) becomes a generic `NOT_FOUND` when the
+ * resolver denies. `EDITOR_NOT_AVAILABLE` (OD's 409 for "installed catalogue
+ * entry, but not found on this machine") becomes `CONFLICT`, which already
+ * maps to 409 in this package's `ERROR_STATUS_BY_CODE`.
+ *
+ * The launch-failure message is returned to the caller verbatim (unlike
+ * `runs.ts`'s SEC-005 redaction of internal agent-run errors): this is a
+ * same-origin, explicitly-consented, single local action the caller just
+ * asked for (open the tool it named, at the directory it's authorized to
+ * open) — the underlying spawn error (e.g. a quarantined/missing binary) is
+ * operationally useful to the caller and does not cross a trust boundary
+ * the way an internal agent-run exception can.
+ */
+export const openResourceInEditorRoute = defineJsonRoute({
+    method: 'post', path: '/api/resources/:resourceRef/open-in', parse: parseOpenResourceInEditor, handle: async ({ input, deps }) => {
+        const entry = CATALOGUE.find((c) => c.id === input.editorId);
+        if (!entry)
+            return err({ error: createApiError({ code: 'BAD_REQUEST', message: `unknown editor: ${input.editorId}` }) });
+        const probeEnv = deps.probeEnv ?? defaultProbeEnv({});
+        if (!applicableForPlatform({ entry, platform: probeEnv.platform })) {
+            return err({ error: createApiError({ code: 'BAD_REQUEST', message: `${entry.label} is not available on ${probeEnv.platform}` }) });
+        }
+        let resolvedDir;
+        try {
+            resolvedDir = await resolveWorkspaceRoot({ request: { resourceRef: input.resourceRef, ...(input.detail === undefined ? {} : { detail: input.detail }) } }, { resolver: deps.resolveRoot ?? denyAllWorkspaceRoots });
+        }
+        catch (error) {
+            if (error instanceof WorkspaceRootDeniedError) {
+                return err({ error: createApiError({ code: 'NOT_FOUND', message: `resource "${input.resourceRef}" was not found` }) });
+            }
+            throw error;
+        }
+        const launchPlan = await resolveHostToolLaunchPlan({ editorId: input.editorId, workingDir: resolvedDir }, { probeEnv });
+        if (!launchPlan.available || !launchPlan.command || !launchPlan.args) {
+            return err({ error: createApiError({ code: 'CONFLICT', message: `${entry.label} is not installed` }) });
+        }
+        const launch = await launchHostTool({ command: launchPlan.command, args: launchPlan.args }, { spawnImpl: deps.spawnImpl ?? nodeSpawn });
+        if (!launch.ok) {
+            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: `failed to launch ${entry.label}: ${launch.error}` }) });
+        }
+        return ok({ value: { ok: true, editorId: input.editorId, path: resolvedDir } });
+    }
+}, { requireSameOrigin: true });
+/** Mounts `GET /api/editors` and `POST /api/resources/:resourceRef/open-in` on `app`. A pack's `http(app, services)` calls this directly. */
+export function registerHostToolsRoutes({ app, adapter }, openInDeps = {}) {
+    mountJsonRoute({ app, spec: hostEditorsRoute, deps: {}, adapter });
+    mountJsonRoute({ app, spec: openResourceInEditorRoute, deps: openInDeps, adapter });
+}
+//# sourceMappingURL=host-tools.js.map

package/dist/http/index.d.ts

@@ -0,0 +1,52 @@
+/** Daemon route packs; generic transport primitives live in @jini-ai/http-kit. */
+export type { ResolveWorkspaceRootOptions, WorkspaceRootRequest, WorkspaceRootResolver, } from './workspace-root.js';
+export { denyAllWorkspaceRoots, resolveWorkspaceRoot, WorkspaceRootDeniedError } from './workspace-root.js';
+export type { RunCancellationService } from './cancel-owned-runs.js';
+export { cancelRunsOwnedBy } from './cancel-owned-runs.js';
+export type { ActiveContextDeps, ActiveContextResource } from './active-context.js';
+export { ACTIVE_CONTEXT_TTL_MS, getActiveRoute, registerActiveContextRoutes, setActiveRoute, } from './active-context.js';
+export type { CatalogueEntry, HostEditor, HostEditorsResponse, HostToolLaunchPlan, HostToolProbeEnv, LaunchHostToolResult, Platform, RealPlatform, } from './host-tools.js';
+export { applicableForPlatform, CATALOGUE, currentPlatform, defaultProbeEnv, hostEditorsRoute, launchHostTool, listAvailableEditors, pathDirs, probeCommandOnPath, probeMacBundle, registerHostToolsRoutes, resolveEntry, resolveHostToolLaunchPlan, } from './host-tools.js';
+export type { DaemonShutdownResponse, DaemonStatusDeps, DaemonStatusResponse, } from './daemon-status.js';
+export { daemonShutdownRoute, daemonStatusRoute, registerDaemonStatusRoutes } from './daemon-status.js';
+export type { RunCancelResponse, RunCreateRequest, RunHttpDeps, RunInternalErrorContext, RunListResponse, RunStartContext, RunStartHandler, RunStartResponse, RunStatusResponse, } from './runs.js';
+export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+export { JINI_ROUTE_MANIFEST, manifestRoutesForFamilies, routeFamilyManifest } from './route-manifest.js';
+export type { AgentListResponse, AgentModelSummary, AgentsHttpDeps, AgentSummary } from './agents.js';
+export { agentListRoute, agentRescanRoute, registerAgentRoutes } from './agents.js';
+export type { MemoryChangeEmitter, MemoryConfigResponse, MemoryDeleteEntryResponse, MemoryEntryInput, MemoryEntryResponse, MemoryExtractionLog, MemoryExtractionsResponse, MemoryHttpDeps, MemoryIndexResponse, MemoryNoteEntry, MemoryNoteEntrySummary, MemoryNoteStore, MemoryNoteStoreOptions, MemoryOverviewResponse, MemoryRemovedResponse, MemoryTreeNode, MemoryTreeNodePatch, MemoryTreeResponse, MemoryUpdateTreeNodeResponse, MemoryVerificationsResponse, MemoryVerifyLog, } from './memory.js';
+export { memoryClearExtractionsRoute, memoryClearVerificationsRoute, memoryCreateEntryRoute, memoryDeleteEntryRoute, memoryListExtractionsRoute, memoryListVerificationsRoute, memoryOverviewRoute, memoryReadEntryRoute, memoryRemoveExtractionRoute, memoryRemoveVerificationRoute, memoryTreeRoute, memoryUpdateEntryRoute, memoryUpdateTreeNodeRoute, memoryWriteConfigRoute, memoryWriteIndexRoute, registerMemoryEventStream, registerMemoryRoutes, } from './memory.js';
+export type { RoutineDeleteResponse, RoutineHttpDeps, RoutineListResponse, RoutineResponse, RoutineRunNowResponse, RoutineRunsResponse, RoutineScheduler, } from './routines.js';
+export { registerRoutineRoutes, routineCreateRoute, routineDeleteRoute, routineGetRoute, routineListRoute, routineRunNowRoute, routineRunsListRoute, routineUpdateRoute, } from './routines.js';
+export type { CreateDaemonDbToolRegistrationsOptions, DaemonDbHttpDeps, DaemonDbInternalErrorContext, DaemonDbOperations, DaemonDbStatusReport, DaemonDbTableInfo, DaemonDbToolRegistrations, DaemonDbVacuumResult, DbIntegrityIssue, DbIntegrityIssueKind, DbIntegrityReport, } from './db-ops.js';
+export { createDaemonDbToolRegistrations, daemonDbInspectRoute, daemonDbVacuumRoute, daemonDbVerifyRoute, DB_INSPECT_TOOL_ID, DB_VACUUM_TOOL_ID, DB_VERIFY_TOOL_ID, denyAllDaemonDbPolicy, registerDaemonDbRoutes, } from './db-ops.js';
+export type { ToolCatalogEntry, ToolCatalogHttpDeps, ToolCatalogQuery, ToolCatalogSearchHit, } from './tool-catalog.js';
+export { registerToolCatalogRoutes, toolCatalogDescribeRoute, toolCatalogSearchRoute, } from './tool-catalog.js';
+export type { ComponentCatalogEntry, ComponentCatalogHttpDeps, ComponentCatalogQuery, ComponentCatalogSearchHit, } from './component-catalog.js';
+export { registerComponentCatalogRoutes, componentCatalogDescribeRoute, componentCatalogSearchRoute, } from './component-catalog.js';
+export type { DelegatedToolExecuteRequest, DelegatedToolExecuteResponse, DelegatedToolsHttpDeps, DelegatedToolsInternalErrorContext, } from './delegated-tools.js';
+export { delegatedToolExecuteRoute, registerDelegatedToolRoutes, } from './delegated-tools.js';
+export type { RemoteRunEventHttpDeps, RemoteRunEventResponse, RemoteToolBridgeTokenConfig, RemoteToolResultRequest, RemoteToolUseRequest, } from './remote-run-events.js';
+export { registerRemoteRunEventRoutes, remoteToolResultRoute, remoteToolUseRoute, requireRemoteToolBridgeToken, } from './remote-run-events.js';
+export type { FrontendSessionAttachedEvent, FrontendSessionErrorEvent, FrontendSessionInvocationEvent, FrontendSessionResponseBody, FrontendSessionResponseRequest, FrontendSessionStreamEvent, FrontendSessionsHttpDeps, } from './frontend-sessions.js';
+export { FRONTEND_SESSION_RESPONSE_ROUTE_PATH, FRONTEND_SESSION_STREAM_ROUTE_PATH, frontendSessionResponseRoute, handleFrontendSessionStream, parseCapabilityQuery, registerFrontendSessionRoutes, } from './frontend-sessions.js';
+export { createFrontendControl } from './frontend-control.js';
+export type { CreateFrontendControlOptions, FrontendBindErrorContext, FrontendControl, FrontendHttpExtension, } from './frontend-control.js';
+export type { TerminalActionResponse, TerminalCreateRequest, TerminalListResponse, TerminalsHttpDeps, TerminalsInternalErrorContext, } from './terminals.js';
+export { registerTerminalEventStream, registerTerminalRoutes, terminalCreateRoute, terminalDeleteRoute, terminalKillRoute, terminalListRoute, terminalResizeRoute, terminalStdinRoute, } from './terminals.js';
+export type { ModelProxyHttpDeps, ModelProxyInternalErrorContext } from './model-proxy.js';
+export { registerModelProxyRoutes } from './model-proxy.js';
+export type { HealthHttpDeps, HealthReadinessResult, LivenessResponse, ReadinessResponse, VersionResponse } from './health.js';
+export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
+export type { AuthCredentials, AuthProvider, AuthSession, AuthUser, Charge, ChargeInput, ChargeStatus, ConnectorsAuthSessionResponse, ConnectorsAuthUserResponse, ConnectorsAuthVerifyResponse, ConnectorsChargeResponse, ConnectorsDbQueryResponse, ConnectorsDbRecordResponse, ConnectorsHttpDeps, ConnectorsInternalErrorContext, ConnectorsOkResponse, ConnectorsStorageGetResponse, ConnectorsStorageListResponse, ConnectorsStorageMetaResponse, DbProvider, DbQuery, DbRecord, PaymentsProvider, RealtimeProvider, StorageObjectMeta, StorageProvider, StoragePutOptions, } from './connectors.js';
+export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
+export type { ResearchHttpDeps, ResearchInternalErrorContext, ResearchProviderCredentials, ResearchSearchResponse, ResearchSource, } from './research.js';
+export { registerResearchRoutes, researchSearchRoute } from './research.js';
+export type { MediaGenerateResponse, MediaHttpDeps, MediaInternalErrorContext, MediaTaskDeleteResponse, MediaTaskListResponse, MediaTaskResponse, } from './media.js';
+export { mediaGenerateRoute, mediaTaskDeleteRoute, mediaTaskGetRoute, mediaTaskListRoute, registerMediaRoutes, } from './media.js';
+export type { AttachmentClaim, AttachmentRejectionReason, AttachmentsHttpDeps, AttachmentsInternalErrorContext, AttachmentStore, AttachmentUploadResponse, CreateDiskAttachmentStoreOptions, ObservedAttachmentIdentity, PendingAttachmentSummary, RecordedAttachmentIdentity, StoredAttachment, } from './attachments.js';
+export { ATTACHMENTS_ROUTE_PATH, AttachmentRejectedError, createDiskAttachmentStore, detectAttachmentKind, handleAttachmentCleanup, handleAttachmentUpload, isUnchangedAttachment, registerAttachmentRoutes, sanitizeAttachmentName, writeBoundedAttachmentBody, } from './attachments.js';
+export type { XaiAuthStatusResponse, XaiHttpDeps, XaiInternalErrorContext, XaiOauthStartResponse, XaiOkResponse, XaiSearchResponse, } from './xai.js';
+export { registerXaiRoutes, xaiAuthStatusRoute, xaiOauthCancelRoute, xaiOauthCompleteRoute, xaiOauthDisconnectRoute, xaiOauthStartRoute, xaiSearchRoute, } from './xai.js';
+export * from './run-credentials.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/index.js

@@ -0,0 +1,27 @@
+export { denyAllWorkspaceRoots, resolveWorkspaceRoot, WorkspaceRootDeniedError } from './workspace-root.js';
+export { cancelRunsOwnedBy } from './cancel-owned-runs.js';
+export { ACTIVE_CONTEXT_TTL_MS, getActiveRoute, registerActiveContextRoutes, setActiveRoute, } from './active-context.js';
+export { applicableForPlatform, CATALOGUE, currentPlatform, defaultProbeEnv, hostEditorsRoute, launchHostTool, listAvailableEditors, pathDirs, probeCommandOnPath, probeMacBundle, registerHostToolsRoutes, resolveEntry, resolveHostToolLaunchPlan, } from './host-tools.js';
+export { daemonShutdownRoute, daemonStatusRoute, registerDaemonStatusRoutes } from './daemon-status.js';
+export { registerRunEventStream, registerRunRoutes, RUN_EVENTS_ROUTE_PATH, runCancelRoute, runListRoute, runStartRoute, runStatusRoute, } from './runs.js';
+export { JINI_ROUTE_MANIFEST, manifestRoutesForFamilies, routeFamilyManifest } from './route-manifest.js';
+export { agentListRoute, agentRescanRoute, registerAgentRoutes } from './agents.js';
+export { memoryClearExtractionsRoute, memoryClearVerificationsRoute, memoryCreateEntryRoute, memoryDeleteEntryRoute, memoryListExtractionsRoute, memoryListVerificationsRoute, memoryOverviewRoute, memoryReadEntryRoute, memoryRemoveExtractionRoute, memoryRemoveVerificationRoute, memoryTreeRoute, memoryUpdateEntryRoute, memoryUpdateTreeNodeRoute, memoryWriteConfigRoute, memoryWriteIndexRoute, registerMemoryEventStream, registerMemoryRoutes, } from './memory.js';
+export { registerRoutineRoutes, routineCreateRoute, routineDeleteRoute, routineGetRoute, routineListRoute, routineRunNowRoute, routineRunsListRoute, routineUpdateRoute, } from './routines.js';
+export { createDaemonDbToolRegistrations, daemonDbInspectRoute, daemonDbVacuumRoute, daemonDbVerifyRoute, DB_INSPECT_TOOL_ID, DB_VACUUM_TOOL_ID, DB_VERIFY_TOOL_ID, denyAllDaemonDbPolicy, registerDaemonDbRoutes, } from './db-ops.js';
+export { registerToolCatalogRoutes, toolCatalogDescribeRoute, toolCatalogSearchRoute, } from './tool-catalog.js';
+export { registerComponentCatalogRoutes, componentCatalogDescribeRoute, componentCatalogSearchRoute, } from './component-catalog.js';
+export { delegatedToolExecuteRoute, registerDelegatedToolRoutes, } from './delegated-tools.js';
+export { registerRemoteRunEventRoutes, remoteToolResultRoute, remoteToolUseRoute, requireRemoteToolBridgeToken, } from './remote-run-events.js';
+export { FRONTEND_SESSION_RESPONSE_ROUTE_PATH, FRONTEND_SESSION_STREAM_ROUTE_PATH, frontendSessionResponseRoute, handleFrontendSessionStream, parseCapabilityQuery, registerFrontendSessionRoutes, } from './frontend-sessions.js';
+export { createFrontendControl } from './frontend-control.js';
+export { registerTerminalEventStream, registerTerminalRoutes, terminalCreateRoute, terminalDeleteRoute, terminalKillRoute, terminalListRoute, terminalResizeRoute, terminalStdinRoute, } from './terminals.js';
+export { registerModelProxyRoutes } from './model-proxy.js';
+export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
+export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
+export { registerResearchRoutes, researchSearchRoute } from './research.js';
+export { mediaGenerateRoute, mediaTaskDeleteRoute, mediaTaskGetRoute, mediaTaskListRoute, registerMediaRoutes, } from './media.js';
+export { ATTACHMENTS_ROUTE_PATH, AttachmentRejectedError, createDiskAttachmentStore, detectAttachmentKind, handleAttachmentCleanup, handleAttachmentUpload, isUnchangedAttachment, registerAttachmentRoutes, sanitizeAttachmentName, writeBoundedAttachmentBody, } from './attachments.js';
+export { registerXaiRoutes, xaiAuthStatusRoute, xaiOauthCancelRoute, xaiOauthCompleteRoute, xaiOauthDisconnectRoute, xaiOauthStartRoute, xaiSearchRoute, } from './xai.js';
+export * from './run-credentials.js';
+//# sourceMappingURL=index.js.map