@realqiyan/agent-task 0.0.1-rc.2 → 0.0.1-rc.3

package/dist/{settings.js → configuration/settings.js}

@@ -1,9 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { z } from "zod";
-import { ADMIN_TOKEN_ENV, configSchema, coordinatorCredentialEnv, validateConfig } from "./config.js";
+import { isDeepStrictEqual } from "node:util";
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv, validateConfig } from "./policy.js";
+import { sameExecutor } from "../executors/registry.js";
 import { parseEnvironment, validateServiceEnvironment } from "./environment.js";
-import { checkDataDirectory, FileCommitError, readPrivateText, replacePrivateText } from "./private-files.js";
-import { credentialUpdateSchema, settingsConfigSchema } from "./settings-contract.js";
+import { FileCommitError } from "../shared/errors.js";
 export class SettingsError extends Error {
     code;
     constructor(code, message) {
@@ -14,15 +14,6 @@ export class SettingsError extends Error {
 const protectedKeys = new Set(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH",
     "PI_ACP_PI_COMMAND", "AGENT_TASK_TOKEN", ADMIN_TOKEN_ENV, "__proto__", "constructor", "prototype"]);
 const modelKeys = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY"];
-function parse(schema, value) {
-    const result = schema.safeParse(value);
-    if (!result.success) {
-        // Field paths only: parser diagnostics and rejected values may contain credentials.
-        const fields = result.error.issues.slice(0, 8).map(issue => issue.path.join(".") || "request");
-        throw new SettingsError("invalid", "Invalid fields: " + fields.join(", "));
-    }
-    return result.data;
-}
 function referenced(config) {
     return new Set(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : []);
 }
@@ -30,10 +21,15 @@ function editableKey(key, config) {
     return !protectedKeys.has(key) && key !== config.tokenEnv && !/^(NODE_|LD_|DYLD_)/.test(key) &&
         (/(?:_KEY|_TOKEN|_SECRET|_PASSWORD)$/.test(key) || referenced(config).has(key));
 }
+export function configChanges(before, after) {
+    return Object.keys(after).concat(Object.keys(before))
+        .filter((key, index, keys) => keys.indexOf(key) === index && !isDeepStrictEqual(before[key], after[key]))
+        .map(field => ({ field, before: before[field] ?? null, after: after[field] ?? null }));
+}
 /** Disk settings are next-start inputs only. This service never mutates live objects or process.env. */
 export class Settings {
-    configPath;
-    environmentPath;
+    files;
+    paths;
     edits = new Map();
     initial;
     running;
@@ -42,11 +38,9 @@ export class Settings {
     closed = false;
     uncertain = false;
     startedAt = new Date().toISOString();
-    constructor(configPath, environmentPath, running, base, environment) {
-        this.configPath = configPath;
-        this.environmentPath = environmentPath;
-        if (configPath === environmentPath)
-            throw new SettingsError("invalid", "Configuration and environment must be separate files");
+    constructor(files, paths, running, base, environment) {
+        this.files = files;
+        this.paths = paths;
         this.running = structuredClone(running);
         this.base = { ...base };
         this.runningEnvironment = { ...environment };
@@ -56,8 +50,7 @@ export class Settings {
         if (this.closed)
             throw new SettingsError("unavailable", "Configuration management is closed");
         try {
-            const configText = readPrivateText(this.configPath), environmentText = readPrivateText(this.environmentPath);
-            return { configText, environmentText, config: configSchema.parse(JSON.parse(configText)), environment: parseEnvironment(environmentText) };
+            return this.files.read();
         }
         catch {
             throw new SettingsError("unavailable", "Cannot read private configuration files; inspect their format, ownership and permissions offline");
@@ -96,19 +89,24 @@ export class Settings {
         }
         return snapshot;
     }
-    candidate(value) {
-        const input = parse(settingsConfigSchema, value), snapshot = this.editing(input.editToken);
+    candidate(input) {
+        const snapshot = this.editing(input.editToken);
         const environment = { ...this.base, ...snapshot.environment };
         let config;
         try {
-            config = validateConfig(input.config);
-            checkDataDirectory(config.dataDir);
+            config = validateConfig(input.config, this.paths.resolveWorkspace);
+            this.paths.checkDataDirectory(config.dataDir);
         }
-        catch (error) {
-            if (error instanceof z.ZodError)
-                throw new SettingsError("invalid", "Invalid configuration fields");
+        catch {
             throw new SettingsError("invalid", "Local validation failed: check data directory, workspaces and credential isolation");
         }
+        for (const executor of config.executors) {
+            const previous = snapshot.config.executors.find(item => item.id === executor.id);
+            if (executor.unattendedApproved && (!previous?.unattendedApproved || !sameExecutor(previous, executor)) &&
+                !input.approveExecutors.includes(executor.id)) {
+                throw new SettingsError("invalid", "Executor changes require explicit approval of the new configuration: " + executor.id);
+            }
+        }
         const previous = snapshot.config.coordinator, next = config.coordinator;
         const endpoint = (model) => model.provider === "openai-compatible" ? model.baseUrl : model.provider;
         if (previous && next && endpoint(previous) !== endpoint(next) && coordinatorCredentialEnv(previous) === coordinatorCredentialEnv(next)) {
@@ -131,19 +129,59 @@ export class Settings {
         return config;
     }
     validate(value) { return this.candidate(value); }
-    saveConfig(value) {
-        const config = this.candidate(value);
-        const snapshot = this.editing(parse(settingsConfigSchema, value).editToken);
+    preview(input) {
+        const config = this.candidate(input);
+        return { config, changes: configChanges(this.editing(input.editToken).config, config) };
+    }
+    diff() {
+        const saved = this.snapshot().config;
+        return { changes: configChanges(this.running, saved), ...this.status() };
+    }
+    /** Convenience commands create a draft; all publication still uses saveConfig. */
+    prepareChange(value) {
+        const { editToken, change } = value;
+        const config = structuredClone(this.editing(editToken).config), approveExecutors = [];
+        if (change.action === "executor-add") {
+            config.executors.push({ ...change.executor, unattendedApproved: false });
+        }
+        else if (change.action === "coordinator-set")
+            config.coordinator = change.coordinator;
+        else if (change.action === "coordinator-clear")
+            delete config.coordinator;
+        else {
+            const executor = config.executors.find(item => item.id === change.id);
+            if (!executor)
+                throw new SettingsError("invalid", "Executor not found");
+            if (change.action === "executor-remove")
+                config.executors = config.executors.filter(item => item !== executor);
+            else if (change.action === "executor-update") {
+                const updated = { ...executor, ...change.patch };
+                if (!sameExecutor(executor, updated))
+                    updated.unattendedApproved = false;
+                config.executors[config.executors.indexOf(executor)] = updated;
+            }
+            else {
+                executor.unattendedApproved = change.action === "executor-approve";
+                if (executor.unattendedApproved)
+                    approveExecutors.push(executor.id);
+            }
+        }
+        const input = { editToken, config, approveExecutors };
+        return { ...input, config: this.candidate(input) };
+    }
+    saveConfig(input) {
+        const config = this.candidate(input);
+        const snapshot = this.editing(input.editToken);
         if (config.tokenEnv !== snapshot.config.tokenEnv) {
             snapshot.environment[config.tokenEnv] = snapshot.environment[snapshot.config.tokenEnv];
             // Publish an alias first. Either configuration still uses the same service token.
-            this.publish(this.environmentPath, snapshot.environment);
+            this.publish("environment", snapshot.environment);
         }
-        this.publish(this.configPath, config);
+        this.publish("config", config);
         return this.get();
     }
-    saveCredential(value) {
-        const input = parse(credentialUpdateSchema, value), snapshot = this.editing(input.editToken);
+    saveCredential(input) {
+        const snapshot = this.editing(input.editToken);
         if (!editableKey(input.key, snapshot.config) || !editableKey(input.key, this.running) ||
             [snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV]].includes(snapshot.environment[input.key]))
             throw new SettingsError("invalid", "This environment key is not console-managed; new credential names must end in _KEY, _TOKEN, _SECRET or _PASSWORD");
@@ -161,12 +199,12 @@ export class Settings {
         }
         // Recheck the complete environment format, not only the edited value.
         parseEnvironment(JSON.stringify(snapshot.environment));
-        this.publish(this.environmentPath, snapshot.environment);
+        this.publish("environment", snapshot.environment);
         return this.get();
     }
-    publish(path, value) {
+    publish(target, value) {
         try {
-            replacePrivateText(path, JSON.stringify(value, null, 2) + "\n");
+            this.files.publish(target, value);
         }
         catch (error) {
             if (error instanceof FileCommitError && error.uncertain)

package/dist/executors/environment.js

@@ -0,0 +1,10 @@
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "../configuration/policy.js";
+/** Private service inputs never enter workers, even through an alias with the same value. */
+export function executorEnvironment(native, privateValues, config) {
+    const blocked = new Set([...Object.keys(privateValues), config.tokenEnv, ADMIN_TOKEN_ENV,
+        ...(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : [])]);
+    const secrets = new Set([...Object.values(privateValues), ...[...blocked].map(key => native[key])].filter(Boolean));
+    return Object.fromEntries(Object.entries(native).filter(([key, value]) => value !== undefined && !blocked.has(key) && !secrets.has(value) &&
+        !/^(AGENT_TASK_|NODE_|LD_|DYLD_)/.test(key) && key !== "PI_ACP_PI_COMMAND"));
+}
+//# sourceMappingURL=environment.js.map

package/dist/executors/model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model.js.map

package/dist/executors/registry.js

@@ -0,0 +1,29 @@
+export function sameExecutor(a, b) {
+    return a.id === b.id && a.type === b.type && a.cwd === b.cwd;
+}
+export function authorizedProfile(snapshot, current) {
+    return Boolean(snapshot?.unattendedApproved && current?.unattendedApproved && sameExecutor(snapshot, current));
+}
+/** Immutable registrations for one service lifetime. Settings apply to the next instance. */
+export class ExecutorRegistry {
+    profiles;
+    constructor(profiles) { this.profiles = structuredClone(profiles); }
+    list() { return { executors: this.profiles.map(profile => ({ ...profile, transport: "stdio" })) }; }
+    snapshot(ids) {
+        const result = Object.create(null);
+        for (const id of ids) {
+            const profile = this.profiles.find(item => item.id === id);
+            if (!profile?.unattendedApproved)
+                throw new Error("Executor not found or not approved: " + id);
+            result[id] = structuredClone(profile);
+        }
+        return result;
+    }
+    authorize(snapshot) {
+        if (!snapshot || !authorizedProfile(snapshot, this.profiles.find(profile => profile.id === snapshot.id))) {
+            throw new Error("Executor authorization revoked or changed");
+        }
+        return structuredClone(snapshot);
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/executors/validation.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { absolutePath, identifier } from "../shared/validation.js";
+export const executorRecord = z.object({
+    id: identifier, type: z.enum(["pi", "codex", "claude", "opencode"]),
+    note: z.string().max(2000), cwd: absolutePath, unattendedApproved: z.boolean(),
+}).strict();
+export const executorSchema = executorRecord.extend({
+    note: executorRecord.shape.note.default(""), unattendedApproved: z.boolean().default(false),
+});
+//# sourceMappingURL=validation.js.map

package/dist/{lock.js → infrastructure/lock.js}

@@ -1,7 +1,7 @@
-import { DatabaseSync } from "node:sqlite";
+import { DatabaseSync } from "./sqlite.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
-/** The stable installation lock prevents two launchers or uninstall during a directory switch. */
+/** The stable installation lock prevents two launchers during a directory switch. */
 export function acquireLauncherLock(home) {
     const db = new DatabaseSync(join(home, "launcher-lock.sqlite"));
     try {

package/dist/{private-files.js → infrastructure/private-files.js}

@@ -1,3 +1,4 @@
+import { FileCommitError } from "../shared/errors.js";
 import { existsSync, constants, openSync, closeSync, fstatSync, lstatSync, realpathSync, readFileSync, writeFileSync, fsyncSync, renameSync, unlinkSync } from "node:fs";
 import { dirname, basename, join, isAbsolute, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -44,13 +45,6 @@ export function readPrivateText(path) {
         closeSync(fd);
     }
 }
-export class FileCommitError extends Error {
-    uncertain;
-    constructor(uncertain) {
-        super(uncertain ? "Configuration publication could not be confirmed; stop and inspect the files" : "Configuration was not published");
-        this.uncertain = uncertain;
-    }
-}
 /** Caller owns the configuration. No await between comparison, validation and publication. */
 export function replacePrivateText(path, text) {
     const temporary = join(dirname(path), "." + basename(path) + "." + randomUUID() + ".tmp");

package/dist/infrastructure/sqlite.js

@@ -0,0 +1,19 @@
+import { createRequire } from "node:module";
+// Node 22 warns on loading SQLite. Suppress only that known notice during the
+// synchronous import, then restore normal warning handling for all other code.
+const emitWarning = process.emitWarning;
+let sqlite;
+try {
+    process.emitWarning = (warning, ...args) => {
+        if (warning === "SQLite is an experimental feature and might change at any time"
+            && args[0] === "ExperimentalWarning")
+            return;
+        Reflect.apply(emitWarning, process, [warning, ...args]);
+    };
+    sqlite = createRequire(import.meta.url)("node:sqlite");
+}
+finally {
+    process.emitWarning = emitWarning;
+}
+export const DatabaseSync = sqlite.DatabaseSync;
+//# sourceMappingURL=sqlite.js.map

package/dist/infrastructure/version.js

@@ -0,0 +1,3 @@
+import { readFileSync } from "node:fs";
+export const version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")).version;
+//# sourceMappingURL=version.js.map

package/dist/{acp.js → integrations/acp/connection.js}

@@ -2,10 +2,11 @@ import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { setTimeout as delay } from "node:timers/promises";
 import * as acp from "@agentclientprotocol/sdk";
-import { executorCommand } from "./executor-runtime.js";
-import { readInputFile } from "./results.js";
-import { permissionDecision } from "./permissions.js";
-import { version } from "./version.js";
+import { executorCommand } from "./runtime.js";
+import { Results } from "../../results/service.js";
+import { LocalResultFiles } from "../../results/files.js";
+import { permissionDecision } from "../../executors/permissions.js";
+import { version } from "../../infrastructure/version.js";
 /** Project only public progress. Queue every piece before yielding so concurrent notifications cannot reorder output. */
 export function progressEvents(update) {
     if (update.sessionUpdate === "agent_message_chunk" && update.content.type === "text") {
@@ -38,7 +39,7 @@ function signalGroup(child, signal) {
         }
     }
 }
-/** Kill the whole group even if its leader already exited; Linux systemd additionally owns a cgroup; macOS does not. */
+/** Kill the whole group even if its leader already exited. */
 export async function terminateGroup(child) {
     signalGroup(child, "SIGTERM");
     await delay(300);
@@ -49,6 +50,7 @@ export async function terminateGroup(child) {
 }
 export async function openAcp(executor, signal, emit, resultsRoot, inputFiles = []) {
     signal.throwIfAborted();
+    const results = new Results(new LocalResultFiles(resultsRoot));
     const launch = executorCommand(executor.type, process.env);
     const child = spawn(launch.command, launch.args, {
         cwd: executor.cwd, env: process.env, detached: true, stdio: ["pipe", "pipe", "pipe"],
@@ -103,7 +105,7 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
             cancel.throwIfAborted();
             if (ctx.params.sessionId !== sessionId)
                 throw new Error("Wrong input-file session");
-            return { content: readInputFile(resultsRoot, inputFiles, ctx.params.path, ctx.params.line ?? 1, ctx.params.limit ?? undefined) };
+            return { content: results.readInputFile(inputFiles, ctx.params.path, ctx.params.line ?? 1, ctx.params.limit ?? undefined) };
         }
         catch (error) {
             controller.abort(error);
@@ -166,4 +168,4 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
         throw error;
     }
 }
-//# sourceMappingURL=acp.js.map
+//# sourceMappingURL=connection.js.map

package/dist/{node-execution.js → integrations/acp/execution.js}

@@ -99,4 +99,4 @@ export const createExecution = (environment) => (input, event, beforeStart) => {
         },
     };
 };
-//# sourceMappingURL=node-execution.js.map
+//# sourceMappingURL=execution.js.map

package/dist/{executor-runtime.js → integrations/acp/runtime.js}

@@ -1,6 +1,5 @@
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, isAbsolute, join } from "node:path";
-import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./config.js";
 const commands = {
     pi: { command: "pi-acp", args: [] },
     codex: { command: "codex-acp", args: [] },
@@ -26,12 +25,4 @@ export function executorCommand(type, environment) {
         find("pi");
     return { command: find(entry.command), args: [...entry.args] };
 }
-/** Private service inputs never enter workers, even through an alias with the same value. */
-export function executorEnvironment(native, privateValues, config) {
-    const blocked = new Set([...Object.keys(privateValues), config.tokenEnv, ADMIN_TOKEN_ENV,
-        ...(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : [])]);
-    const secrets = new Set([...Object.values(privateValues), ...[...blocked].map(key => native[key])].filter(Boolean));
-    return Object.fromEntries(Object.entries(native).filter(([key, value]) => value !== undefined && !blocked.has(key) && !secrets.has(value) &&
-        !/^(AGENT_TASK_|NODE_|LD_|DYLD_)/.test(key) && key !== "PI_ACP_PI_COMMAND"));
-}
-//# sourceMappingURL=executor-runtime.js.map
+//# sourceMappingURL=runtime.js.map

package/dist/{worker.js → integrations/acp/worker.js}

@@ -1,6 +1,7 @@
-import { openAcp } from "./acp.js";
+import { openAcp } from "./connection.js";
 import { z } from "zod";
-import { errorText, executorSchema } from "./model.js";
+import { errorText } from "../../shared/errors.js";
+import { executorSchema } from "../../executors/validation.js";
 const inputSchema = z.object({ executor: executorSchema, inputFiles: z.array(z.string()).max(20), resultsRoot: z.string().min(1) }).strict();
 const controller = new AbortController();
 const pending = new Map();

package/dist/{coordinator.js → integrations/coordinator/coordinator.js}

@@ -1,9 +1,9 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { Type } from "@earendil-works/pi-ai";
 import { createModels } from "@earendil-works/pi-ai/models";
-import { createCoordinatorProvider } from "./coordinator-provider.js";
+import { createCoordinatorProvider } from "./provider.js";
 import { createRegistry, defineExtension, defineTool, Harness, section } from "@earendil-works/pi-durable";
-import { openCoordinatorStorage } from "./coordinator-storage.js";
+import { openCoordinatorStorage } from "./storage.js";
 const instructions = `You advance one persisted task run using the DAG supplied by the caller. External ACP agents do all domain work.
 Start with inspect_run. The nodes, prompts, dependencies and assigned executorIds are already fixed. Do not decompose the task, add nodes, replace the plan or switch executors.
 Use converse to start a pending node only after all direct dependencies have accepted deliveries. Its first turn uses the caller-supplied node prompt. Independent nodes may run concurrently.
@@ -79,7 +79,8 @@ export function createCoordinator(directory, config) {
                 tool({ name: "request_input", description: "Persist a question and suspend this run for human facts. Only after all ACP turns finish. Not permission approval.",
                     parameters: Type.Object({ nodeId: Type.Optional(Type.String()),
                         question: Type.String({ minLength: 1, maxLength: 4000 }), completedWork: Type.String({ minLength: 1, maxLength: 4000 }) }), replay: "unsafe",
-                    execute: async (args) => ({ ...output(actions.ask(args)), control: { terminate: true } }) }),
+                    execute: async (args) => ({ ...output(actions.ask({ ...args, question: args.question.trim(), completedWork: args.completedWork.trim() })),
+                        control: { terminate: true } }) }),
                 tool({ name: "stop_run", description: "Stop without success for an unachievable task. Use request_input for missing user facts.",
                     parameters: Type.Object({ status: Type.Literal("failed"),
                         reason: Type.String({ minLength: 1, maxLength: 4000 }) }), replay: "unsafe",
@@ -87,10 +88,18 @@ export function createCoordinator(directory, config) {
             ],
         }));
         const storage = await openCoordinatorStorage(directory, runId);
-        const harness = await Harness.open(storage, {
-            models, registry,
-            settings: { retry: { enabled: false }, stream: { maxRetries: 0, timeoutMs: 120000 } },
-        }, context);
+        let harness;
+        try {
+            harness = await Harness.open(storage, {
+                models, registry,
+                settings: { retry: { enabled: false }, stream: { maxRetries: 0, timeoutMs: 120000 } },
+            }, context);
+        }
+        catch (error) {
+            // Ownership transfers to Harness only after open succeeds. Storage close is idempotent.
+            await storage.close(context);
+            throw error;
+        }
         // Close rather than mark durable tasks aborted. A safe run may resume its same submission after restart.
         const abort = () => { void harness.close(context).catch(() => { }); };
         signal.addEventListener("abort", abort, { once: true });

package/dist/{coordinator-provider.js → integrations/coordinator/provider.js}

@@ -25,4 +25,4 @@ export function createCoordinatorProvider(config) {
         });
     }
 }
-//# sourceMappingURL=coordinator-provider.js.map
+//# sourceMappingURL=provider.js.map

package/dist/{coordinator-storage.js → integrations/coordinator/storage.js}

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { DatabaseSync } from "../../infrastructure/sqlite.js";
 import { SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
 import { openNodeSqliteDatabase } from "@earendil-works/pi-durable/storage/sqlite/node";
 /** The caller holds the application directory lock. New files initialize; existing files must already match the pinned SDK. */
@@ -40,4 +40,4 @@ export async function openCoordinatorStorage(directory, runId) {
         throw error;
     }
 }
-//# sourceMappingURL=coordinator-storage.js.map
+//# sourceMappingURL=storage.js.map

package/dist/integrations/local-service/control.js

@@ -0,0 +1,33 @@
+import { request } from "node:http";
+import { join } from "node:path";
+import { startupPaths } from "../../configuration/files.js";
+/** Local administrator capability: the socket lives in the private launcher directory. */
+export function controlService(home, action) {
+    startupPaths(home);
+    return new Promise((resolve, reject) => {
+        let timedOut = false;
+        const req = request({ socketPath: join(home, "control.sock"), path: "/" + action, method: "POST" }, res => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => { body += chunk; });
+            res.on("end", () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error("Service unavailable; inspect private logs and startup files"));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    reject(new Error("Invalid launcher response"));
+                }
+            });
+        });
+        req.setTimeout(60_000, () => { timedOut = true; req.destroy(); });
+        req.once("error", () => reject(new Error(timedOut
+            ? "Service control timed out; outcome is unknown, check status before another restart"
+            : "Cannot contact launcher; start the foreground or managed service first")));
+        req.end();
+    });
+}
+//# sourceMappingURL=control.js.map

package/dist/protocol/cli/admin-client.js

@@ -0,0 +1,45 @@
+import { controlService } from "../../integrations/local-service/control.js";
+import { startupPaths } from "../../configuration/files.js";
+import { readEnvironment } from "../../configuration/files.js";
+import { ADMIN_TOKEN_ENV } from "../../configuration/policy.js";
+/** Local CLI transport. Credentials never enter arguments, URLs or diagnostics. */
+export async function connectAdmin(home) {
+    const ready = await controlService(home, "status");
+    if (!ready.consoleUrl)
+        throw new Error("Administrator API is disabled; configure an administrator token while stopped");
+    const url = new URL(ready.consoleUrl);
+    if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.username || url.password) {
+        throw new Error("Invalid local administrator address");
+    }
+    const token = readEnvironment(startupPaths(home).environmentPath)[ADMIN_TOKEN_ENV];
+    if (!token)
+        throw new Error("Administrator credential is unavailable");
+    return {
+        ready,
+        async request(path, input) {
+            let response;
+            try {
+                response = await fetch(url.origin + "/admin/api" + path, {
+                    method: input === undefined ? "GET" : "POST", redirect: "error",
+                    headers: { Authorization: "Bearer " + token,
+                        ...(input === undefined ? {} : { Origin: url.origin, "Content-Type": "application/json" }) },
+                    body: input === undefined ? undefined : JSON.stringify(input), signal: AbortSignal.timeout(60_000),
+                });
+            }
+            catch {
+                throw new Error("Administrator request could not be confirmed; inspect current state before retrying. No offline write was attempted");
+            }
+            let body;
+            try {
+                body = await response.json();
+            }
+            catch {
+                throw new Error("Invalid administrator response");
+            }
+            if (!response.ok)
+                throw new Error(body.error ?? "Administrator request rejected (HTTP " + response.status + ")");
+            return body.data;
+        },
+    };
+}
+//# sourceMappingURL=admin-client.js.map