@zq-silk/yui 0.2.0 → 0.4.2

package/dist/domain/validation.js

@@ -0,0 +1,53 @@
+export function requireIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if ([".", "..", "__proto__", "prototype", "constructor"].includes(normalized)
+        || /[\/\\\0]/u.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+export function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0")) {
+        throw new Error(`${label} is invalid.`);
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+export function optionalText(value, label) {
+    return value === undefined ? undefined : requireText(value, label);
+}
+export function requireTimestamp(value, label) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be an ISO timestamp.`);
+    }
+    return value;
+}
+export function requirePositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return value;
+}
+export function normalizedUniqueText(values, label) {
+    if (!Array.isArray(values))
+        throw new Error(`${label} must be an array.`);
+    const normalized = values.map((value) => requireText(value, label));
+    if (new Set(normalized).size !== normalized.length) {
+        throw new Error(`${label} must be unique.`);
+    }
+    return Object.freeze(normalized);
+}
+export function normalizedUniqueIdentities(values, label) {
+    if (!Array.isArray(values))
+        throw new Error(`${label} must be an array.`);
+    const normalized = values.map((value) => requireIdentity(value, label));
+    if (new Set(normalized).size !== normalized.length) {
+        throw new Error(`${label} must be unique.`);
+    }
+    return Object.freeze(normalized);
+}
+export function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/errors/cliError.js

@@ -9,17 +9,19 @@ const EXIT_CODES = {
 export class CliError extends Error {
     code;
     helpText;
+    details;
     exitCode;
-    constructor(code, message, helpText) {
+    constructor(code, message, helpText, details = {}) {
         super(message);
         this.code = code;
         this.helpText = helpText;
+        this.details = details;
         this.name = "CliError";
         this.exitCode = EXIT_CODES[code];
     }
 }
-export function usageError(message, helpText) {
-    return new CliError("USAGE_ERROR", message, helpText);
+export function usageError(message, helpText, details = {}) {
+    return new CliError("USAGE_ERROR", message, helpText, details);
 }
 export function taskNotFound(id) {
     return new CliError("TASK_NOT_FOUND", `Task not found: ${id}`);

package/dist/event/taskEvent.js

@@ -1,11 +1,15 @@
-export function createTaskEvent(id, type, payload, now) {
-    return {
-        schemaVersion: 1,
+import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+export function createTaskEvent(id, taskId, type, payload, now) {
+    const event = {
+        schemaVersion: 2,
         id: requireText(id, "Task event id"),
+        taskId: requireText(taskId, "Task event Task id"),
         type: requireText(type, "Task event type"),
         payload: normalizePayload(payload),
         createdAt: now.toISOString()
     };
+    validateTaskRecordReference({ taskId: event.taskId, localId: event.id }, "event");
+    return event;
 }
 /**
  * Builds the next Event history without mutating or replacing an existing entry.

package/dist/execution/codexThreadNaming.js

@@ -0,0 +1,160 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { YUI_VERSION } from "../version.js";
+const DEFAULT_TIMEOUT_MS = 1_000;
+export async function setCodexThreadName(request) {
+    const timeoutMs = threadNameTimeout(request.timeoutMs);
+    const client = await CodexNamingClient.start(request.command, request.environment, request.baseArgs ?? [], timeoutMs);
+    try {
+        await withTimeout(client.request("thread/name/set", {
+            threadId: requiredText(request.threadId, "Codex thread id"),
+            name: requiredThreadName(request.name)
+        }), timeoutMs, "Timed out setting Codex thread name.");
+    }
+    finally {
+        client.close();
+    }
+}
+class CodexNamingClient {
+    child;
+    #pending = new Map();
+    #stderr = [];
+    #nextId = 1;
+    #closed = false;
+    constructor(child) {
+        this.child = child;
+        const output = createInterface({ input: child.stdout });
+        output.on("line", (line) => { this.#receive(line); });
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            this.#stderr.push(chunk);
+            if (this.#stderr.join("").length > 16_384)
+                this.#stderr.shift();
+        });
+        child.on("error", (error) => { this.#failAll(error); });
+        child.on("exit", (code, signal) => {
+            if (this.#closed)
+                return;
+            const detail = this.#stderr.join("").trim();
+            this.#failAll(new Error(`Codex App Server exited (${code ?? signal ?? "unknown"})${detail.length === 0 ? "" : `: ${detail}`}`));
+        });
+    }
+    static async start(command, environment, baseArgs, timeoutMs) {
+        const client = new CodexNamingClient(spawn(command, [...baseArgs, "app-server", "--stdio"], { env: environment, stdio: ["pipe", "pipe", "pipe"] }));
+        try {
+            await withTimeout(client.request("initialize", {
+                clientInfo: { name: "yui", title: "Yui", version: YUI_VERSION },
+                capabilities: {
+                    experimentalApi: true,
+                    requestAttestation: false
+                }
+            }), timeoutMs, "Timed out initializing Codex App Server for thread naming.");
+            client.notify("initialized", {});
+            return client;
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+    }
+    request(method, params) {
+        if (this.#closed)
+            return Promise.reject(new Error("Codex App Server is closed."));
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject });
+            this.#write({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.#write({ method, params });
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.child.kill("SIGTERM");
+        this.#failAll(new Error("Codex App Server closed."));
+    }
+    #write(value) {
+        this.child.stdin.write(`${JSON.stringify(value)}\n`);
+    }
+    #receive(line) {
+        let message;
+        try {
+            message = object(JSON.parse(line), "Codex App Server message");
+        }
+        catch (error) {
+            this.#failAll(error instanceof Error ? error : new Error(String(error)));
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const pending = this.#pending.get(message.id);
+        if (pending === undefined) {
+            if (typeof message.method === "string") {
+                this.#write({
+                    id: message.id,
+                    error: { code: -32601, message: `Unsupported App Server request: ${message.method}` }
+                });
+            }
+            return;
+        }
+        this.#pending.delete(message.id);
+        if (message.error !== undefined) {
+            const error = object(message.error, "Codex App Server error");
+            pending.reject(new Error(typeof error.message === "string" ? error.message : "Codex App Server request failed."));
+        }
+        else {
+            pending.resolve(object(message.result, "Codex App Server result"));
+        }
+    }
+    #failAll(error) {
+        for (const pending of this.#pending.values())
+            pending.reject(error);
+        this.#pending.clear();
+    }
+}
+function object(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value;
+}
+function requiredText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value;
+}
+function requiredThreadName(value) {
+    if (typeof value !== "string" || value.includes("\0")) {
+        throw new Error("Codex thread name is invalid.");
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0 || normalized.length > 1_024) {
+        throw new Error("Codex thread name is invalid.");
+    }
+    return normalized;
+}
+function threadNameTimeout(value) {
+    if (value === undefined)
+        return DEFAULT_TIMEOUT_MS;
+    if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > 10_000) {
+        throw new Error("Codex thread name timeout is invalid.");
+    }
+    return Number(value);
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => { reject(new Error(message)); }, timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}