@twinklerg/coden 0.1.0

package/src/plugins/transaction.ts

@@ -0,0 +1,403 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { CodeNError } from "../core/types.js";
+import type { PluginPaths } from "./paths.js";
+
+export type TransactionPoint = "after-backup" | "after-runtime-commit" | "after-manifest-commit";
+
+export interface PluginTransactionCandidate {
+  manifestPath: string;
+  runtimeDir: string;
+}
+
+export interface PluginTransactionOptions {
+  fault?: (point: TransactionPoint) => void;
+  now?: () => number;
+  isProcessAlive?: (pid: number) => boolean;
+}
+
+interface TransactionMarker {
+  version: 1;
+  id: string;
+  phase: "prepared" | "backed-up" | "runtime-committed" | "manifest-committed";
+  stageDirectory: string;
+  backupManifestPath: string;
+  backupRuntimeDir: string;
+  hadManifest: boolean;
+  hadRuntime: boolean;
+}
+
+interface LockOwner {
+  pid: number;
+  createdAt: number;
+}
+
+class FaultInterruption extends Error {
+  constructor(cause: unknown) {
+    super(
+      cause instanceof Error ? cause.message : String(cause),
+      cause instanceof Error ? { cause } : undefined,
+    );
+    this.name = "FaultInterruption";
+  }
+}
+
+export class PluginTransaction {
+  constructor(
+    private readonly paths: PluginPaths,
+    private readonly options: PluginTransactionOptions = {},
+  ) {}
+
+  async run<T>(builder: (candidate: PluginTransactionCandidate) => Promise<T>): Promise<T> {
+    let ownsLock = false;
+    let marker: TransactionMarker | undefined;
+    try {
+      await this.acquireLock();
+      ownsLock = true;
+      await this.recoverLocked();
+
+      const id = randomUUID();
+      const stageDirectory = path.join(this.paths.root, `.transaction-${id}-stage`);
+      marker = {
+        version: 1,
+        id,
+        phase: "prepared",
+        stageDirectory,
+        backupManifestPath: path.join(this.paths.root, `.transaction-${id}-plugins.json.bak`),
+        backupRuntimeDir: path.join(this.paths.root, `.transaction-${id}-runtime.bak`),
+        hadManifest: await pathExists(this.paths.manifestPath),
+        hadRuntime: await pathExists(this.paths.runtimeDir),
+      };
+
+      await mkdir(stageDirectory, { recursive: true });
+      const candidate = {
+        manifestPath: path.join(stageDirectory, "plugins.json"),
+        runtimeDir: path.join(stageDirectory, "runtime"),
+      };
+      const result = await builder(candidate);
+      await this.verifyCandidate(candidate);
+
+      await this.writeMarker(marker);
+      await this.backupCurrent(marker);
+
+      const backedUpMarker: TransactionMarker = { ...marker, phase: "backed-up" };
+      await this.writeMarker(backedUpMarker);
+      marker = backedUpMarker;
+      this.fault("after-backup");
+
+      await rename(candidate.runtimeDir, this.paths.runtimeDir);
+      const runtimeCommittedMarker: TransactionMarker = {
+        ...marker,
+        phase: "runtime-committed",
+      };
+      await this.writeMarker(runtimeCommittedMarker);
+      marker = runtimeCommittedMarker;
+      this.fault("after-runtime-commit");
+
+      await rename(candidate.manifestPath, this.paths.manifestPath);
+      const manifestCommittedMarker: TransactionMarker = {
+        ...marker,
+        phase: "manifest-committed",
+      };
+      await this.writeMarker(manifestCommittedMarker);
+      marker = manifestCommittedMarker;
+      this.fault("after-manifest-commit");
+
+      await this.cleanupCommitted(marker);
+      return result;
+    } catch (error) {
+      if (error instanceof FaultInterruption) throw error.cause ?? error;
+      await this.rollbackAfterError(marker);
+      throw error;
+    } finally {
+      if (ownsLock) await this.releaseLock();
+    }
+  }
+
+  async recover(): Promise<void> {
+    let ownsLock = false;
+    try {
+      await this.acquireLock();
+      ownsLock = true;
+      await this.recoverLocked();
+    } finally {
+      if (ownsLock) await this.releaseLock();
+    }
+  }
+
+  private async acquireLock(): Promise<void> {
+    await mkdir(this.paths.root, { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        await mkdir(this.paths.lockPath);
+      } catch (error) {
+        if (!isFileSystemError(error, "EEXIST")) throw error;
+        const owner = await this.readLockOwner();
+        if (!owner || this.isProcessAlive(owner.pid)) {
+          throw new CodeNError(
+            "plugin",
+            "plugin.install_busy",
+            `plugin.install_busy: ${this.paths.scope} plugin installation is already running`,
+            true,
+            { scope: this.paths.scope },
+          );
+        }
+        if (attempt === 1) {
+          throw new CodeNError(
+            "plugin",
+            "plugin.install_busy",
+            `plugin.install_busy: could not acquire ${this.paths.scope} plugin lock`,
+            true,
+            { scope: this.paths.scope },
+          );
+        }
+        await rm(this.paths.lockPath, { recursive: true, force: true });
+        continue;
+      }
+
+      try {
+        await writeFile(
+          path.join(this.paths.lockPath, "owner.json"),
+          `${JSON.stringify({ pid: process.pid, createdAt: this.now() } satisfies LockOwner)}\n`,
+          { mode: 0o600 },
+        );
+        return;
+      } catch (error) {
+        await rm(this.paths.lockPath, { recursive: true, force: true });
+        throw error;
+      }
+    }
+  }
+
+  private async readLockOwner(): Promise<LockOwner | undefined> {
+    try {
+      const owner = JSON.parse(
+        await readFile(path.join(this.paths.lockPath, "owner.json"), "utf8"),
+      ) as Partial<LockOwner>;
+      if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+        return {
+          pid: owner.pid,
+          createdAt: typeof owner.createdAt === "number" ? owner.createdAt : 0,
+        };
+      }
+      return undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  private async releaseLock(): Promise<void> {
+    await rm(this.paths.lockPath, { recursive: true, force: true });
+  }
+
+  private async verifyCandidate(candidate: PluginTransactionCandidate): Promise<void> {
+    if (!(await pathExists(candidate.manifestPath)) || !(await pathExists(candidate.runtimeDir))) {
+      throw new CodeNError(
+        "plugin",
+        "plugin.transaction_recovery_failed",
+        "plugin.transaction_recovery_failed: candidate manifest and runtime are required",
+        false,
+        { scope: this.paths.scope },
+      );
+    }
+  }
+
+  private async backupCurrent(marker: TransactionMarker): Promise<void> {
+    await rm(marker.backupManifestPath, { force: true });
+    await rm(marker.backupRuntimeDir, { recursive: true, force: true });
+    if (marker.hadManifest) await rename(this.paths.manifestPath, marker.backupManifestPath);
+    if (marker.hadRuntime) await rename(this.paths.runtimeDir, marker.backupRuntimeDir);
+  }
+
+  private async rollbackAfterError(marker: TransactionMarker | undefined): Promise<void> {
+    if (!marker) return;
+    try {
+      if (marker.phase === "manifest-committed") {
+        await this.cleanupCommitted(marker);
+        return;
+      }
+      await this.restoreBackupPairBestEffort(marker);
+      await this.cleanupRecoveryArtifacts(marker);
+    } catch (error) {
+      throw new CodeNError(
+        "plugin",
+        "plugin.transaction_recovery_failed",
+        `plugin.transaction_recovery_failed: could not roll back ${this.paths.scope} plugin transaction`,
+        false,
+        { scope: this.paths.scope },
+        error instanceof Error ? { cause: error } : undefined,
+      );
+    }
+  }
+
+  private async recoverLocked(): Promise<void> {
+    const marker = await this.readMarker();
+    if (!marker) return;
+
+    try {
+      if (marker.phase === "prepared") {
+        await rm(marker.stageDirectory, { recursive: true, force: true });
+        await rm(this.paths.transactionPath, { force: true });
+        return;
+      }
+
+      if (marker.phase === "backed-up" || marker.phase === "runtime-committed") {
+        await this.removeCurrentTargets();
+        await this.restoreBackups(marker);
+        await this.cleanupRecoveryArtifacts(marker);
+        return;
+      }
+
+      await rm(marker.backupManifestPath, { force: true });
+      await rm(marker.backupRuntimeDir, { recursive: true, force: true });
+      await this.cleanupRecoveryArtifacts(marker);
+    } catch (error) {
+      throw new CodeNError(
+        "plugin",
+        "plugin.transaction_recovery_failed",
+        `plugin.transaction_recovery_failed: could not recover ${this.paths.scope} plugin transaction`,
+        false,
+        { scope: this.paths.scope },
+        error instanceof Error ? { cause: error } : undefined,
+      );
+    }
+  }
+
+  private async readMarker(): Promise<TransactionMarker | undefined> {
+    try {
+      const marker = JSON.parse(
+        await readFile(this.paths.transactionPath, "utf8"),
+      ) as Partial<TransactionMarker>;
+      if (!isTransactionMarker(marker)) throw new Error("invalid transaction marker");
+      return marker;
+    } catch (error) {
+      if (isFileSystemError(error, "ENOENT")) return undefined;
+      throw new CodeNError(
+        "plugin",
+        "plugin.transaction_recovery_failed",
+        `plugin.transaction_recovery_failed: invalid ${this.paths.scope} plugin transaction marker`,
+        false,
+        { scope: this.paths.scope },
+        error instanceof Error ? { cause: error } : undefined,
+      );
+    }
+  }
+
+  private async writeMarker(marker: TransactionMarker): Promise<void> {
+    await mkdir(path.dirname(this.paths.transactionPath), { recursive: true });
+    const temporaryPath = `${this.paths.transactionPath}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(marker, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporaryPath, this.paths.transactionPath);
+  }
+
+  private async cleanupCommitted(marker: TransactionMarker): Promise<void> {
+    await rm(marker.backupManifestPath, { force: true });
+    await rm(marker.backupRuntimeDir, { recursive: true, force: true });
+    await rm(marker.stageDirectory, { recursive: true, force: true });
+    await rm(this.paths.transactionPath, { force: true });
+    await rm(`${this.paths.transactionPath}.tmp`, { recursive: true, force: true });
+  }
+
+  private async cleanupRecoveryArtifacts(marker: TransactionMarker): Promise<void> {
+    await rm(marker.stageDirectory, { recursive: true, force: true });
+    await rm(this.paths.transactionPath, { force: true });
+    await rm(`${this.paths.transactionPath}.tmp`, { recursive: true, force: true });
+  }
+
+  private async removeCurrentTargets(): Promise<void> {
+    await rm(this.paths.manifestPath, { force: true });
+    await rm(this.paths.runtimeDir, { recursive: true, force: true });
+  }
+
+  private async restoreBackups(marker: TransactionMarker): Promise<void> {
+    if (marker.hadManifest) await rename(marker.backupManifestPath, this.paths.manifestPath);
+    if (marker.hadRuntime) await rename(marker.backupRuntimeDir, this.paths.runtimeDir);
+  }
+
+  private async restoreBackupPairBestEffort(marker: TransactionMarker): Promise<void> {
+    await this.restoreSingleBackup({
+      hadTarget: marker.hadManifest,
+      backupPath: marker.backupManifestPath,
+      targetPath: this.paths.manifestPath,
+      directory: false,
+    });
+    await this.restoreSingleBackup({
+      hadTarget: marker.hadRuntime,
+      backupPath: marker.backupRuntimeDir,
+      targetPath: this.paths.runtimeDir,
+      directory: true,
+    });
+  }
+
+  private async restoreSingleBackup(options: {
+    hadTarget: boolean;
+    backupPath: string;
+    targetPath: string;
+    directory: boolean;
+  }): Promise<void> {
+    if (await pathExists(options.backupPath)) {
+      await rm(options.targetPath, { recursive: options.directory, force: true });
+      await rename(options.backupPath, options.targetPath);
+      return;
+    }
+    if (!options.hadTarget)
+      await rm(options.targetPath, { recursive: options.directory, force: true });
+  }
+
+  private fault(point: TransactionPoint): void {
+    try {
+      this.options.fault?.(point);
+    } catch (error) {
+      throw new FaultInterruption(error);
+    }
+  }
+
+  private now(): number {
+    return this.options.now?.() ?? Date.now();
+  }
+
+  private isProcessAlive(pid: number): boolean {
+    if (this.options.isProcessAlive) return this.options.isProcessAlive(pid);
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return !isFileSystemError(error, "ESRCH");
+    }
+  }
+}
+
+function isTransactionMarker(value: Partial<TransactionMarker>): value is TransactionMarker {
+  return (
+    value.version === 1 &&
+    typeof value.id === "string" &&
+    ["prepared", "backed-up", "runtime-committed", "manifest-committed"].includes(
+      String(value.phase),
+    ) &&
+    typeof value.stageDirectory === "string" &&
+    typeof value.backupManifestPath === "string" &&
+    typeof value.backupRuntimeDir === "string" &&
+    typeof value.hadManifest === "boolean" &&
+    typeof value.hadRuntime === "boolean"
+  );
+}
+
+async function pathExists(file: string): Promise<boolean> {
+  try {
+    await access(file, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isFileSystemError(error: unknown, code: string): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as { code?: string }).code === code
+  );
+}

package/src/process/runner.ts

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+
+class BoundedCollector {
+  private readonly headLimit: number;
+  private readonly tailLimit: number;
+  private head = "";
+  private tail = "";
+  private total = 0;
+
+  constructor(maxChars: number) {
+    this.headLimit = Math.ceil(maxChars * 0.6);
+    this.tailLimit = Math.floor(maxChars * 0.4);
+  }
+
+  add(chunk: string): void {
+    this.total += chunk.length;
+    const needed = Math.max(0, this.headLimit - this.head.length);
+    this.head += chunk.slice(0, needed);
+    const remainder = chunk.slice(needed);
+    if (remainder) this.tail = `${this.tail}${remainder}`.slice(-this.tailLimit);
+  }
+
+  value(): string {
+    const omitted = this.total - this.head.length - this.tail.length;
+    return omitted > 0
+      ? `${this.head}\n... [${omitted} characters omitted while capturing] ...\n${this.tail}`
+      : `${this.head}${this.tail}`;
+  }
+}
+
+export interface ProcessRunOptions {
+  cwd: string;
+  env?: NodeJS.ProcessEnv;
+  signal?: AbortSignal;
+  timeoutMs: number;
+  maxOutputChars: number;
+}
+
+export interface ProcessRunResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+  signal: NodeJS.Signals | null;
+  timedOut: boolean;
+  cancelled: boolean;
+}
+
+export type ProcessRunner = (
+  command: string,
+  args: string[],
+  options: ProcessRunOptions,
+) => Promise<ProcessRunResult>;
+
+export const runProcess: ProcessRunner = (command, args, options) =>
+  new Promise((resolve) => {
+    const grouped = process.platform !== "win32";
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: grouped,
+    });
+    const stdout = new BoundedCollector(options.maxOutputChars);
+    const stderr = new BoundedCollector(options.maxOutputChars);
+    let timedOut = false;
+    let cancelled = false;
+    let settled = false;
+    let escalation: NodeJS.Timeout | undefined;
+    let timer: NodeJS.Timeout;
+
+    const terminate = (signal: NodeJS.Signals) => {
+      if (grouped && child.pid) {
+        try {
+          process.kill(-child.pid, signal);
+          return;
+        } catch {
+          // The process group may already have exited; kill the child directly.
+        }
+      }
+      child.kill(signal);
+    };
+    const finish = (exitCode: number | null, signal: NodeJS.Signals | null) => {
+      if (settled) return;
+      if ((timedOut || cancelled) && grouped && child.pid) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+        } catch {
+          // The leader or group may already be gone; resolving below is still safe.
+        }
+      }
+      settled = true;
+      clearTimeout(timer);
+      if (escalation) clearTimeout(escalation);
+      options.signal?.removeEventListener("abort", cancel);
+      resolve({
+        ok: !timedOut && !cancelled && exitCode === 0,
+        stdout: stdout.value(),
+        stderr: stderr.value(),
+        exitCode,
+        signal,
+        timedOut,
+        cancelled,
+      });
+    };
+    const escalate = () => {
+      if (escalation) return;
+      escalation = setTimeout(() => terminate("SIGKILL"), 500);
+      escalation.unref();
+    };
+    const cancel = () => {
+      if (cancelled) return;
+      cancelled = true;
+      terminate("SIGTERM");
+      escalate();
+    };
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => stdout.add(chunk));
+    child.stderr.on("data", (chunk: string) => stderr.add(chunk));
+    child.once("error", (error) => {
+      stderr.add(error.message);
+      finish(null, null);
+    });
+    child.once("close", finish);
+    if (options.signal?.aborted) cancel();
+    else options.signal?.addEventListener("abort", cancel, { once: true });
+    timer = setTimeout(() => {
+      timedOut = true;
+      terminate("SIGTERM");
+      escalate();
+    }, options.timeoutMs);
+  });

package/src/providers/anthropic.ts

@@ -0,0 +1,117 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { Tool as AnthropicTool, MessageParam } from "@anthropic-ai/sdk/resources/messages";
+import type { AgentMessage, ModelEvent, ModelProvider, ModelRequest } from "../core/types.js";
+
+export interface AnthropicProviderOptions {
+  apiKey: string;
+  baseURL?: string;
+}
+export class AnthropicProvider implements ModelProvider {
+  private readonly client: Anthropic;
+  constructor(options: AnthropicProviderOptions) {
+    this.client = new Anthropic({ ...options, maxRetries: 0 });
+  }
+  async *stream(request: ModelRequest): AsyncIterable<ModelEvent> {
+    const { system, messages } = toAnthropicMessages(request.messages);
+    const stream = this.client.messages.stream(
+      {
+        model: request.model,
+        system,
+        messages,
+        max_tokens: request.maxOutputTokens,
+        ...(request.tools.length
+          ? {
+              tools: request.tools.map(
+                (tool): AnthropicTool => ({
+                  name: tool.name,
+                  description: tool.description,
+                  input_schema: tool.inputSchema as AnthropicTool.InputSchema,
+                }),
+              ),
+            }
+          : {}),
+      },
+      request.signal ? { signal: request.signal } : undefined,
+    );
+    const inputByIndex = new Map<number, string>();
+    for await (const event of stream) {
+      if (event.type === "content_block_start" && event.content_block.type === "tool_use") {
+        inputByIndex.set(event.index, "");
+        yield {
+          type: "tool_call_start",
+          index: event.index,
+          callId: event.content_block.id,
+          name: event.content_block.name,
+        };
+      } else if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield { type: "text_delta", text: event.delta.text };
+      } else if (event.type === "content_block_delta" && event.delta.type === "input_json_delta") {
+        inputByIndex.set(
+          event.index,
+          (inputByIndex.get(event.index) ?? "") + event.delta.partial_json,
+        );
+        yield {
+          type: "tool_call_delta",
+          index: event.index,
+          argumentsDelta: event.delta.partial_json,
+        };
+      } else if (event.type === "content_block_stop" && inputByIndex.has(event.index)) {
+        yield { type: "tool_call_end", index: event.index };
+      } else if (event.type === "message_start") {
+        yield {
+          type: "usage",
+          usage: {
+            inputTokens: event.message.usage.input_tokens,
+            outputTokens: event.message.usage.output_tokens,
+          },
+        };
+      } else if (event.type === "message_delta") {
+        yield { type: "usage", usage: { inputTokens: 0, outputTokens: event.usage.output_tokens } };
+      }
+    }
+    yield { type: "done" };
+  }
+}
+
+export function toAnthropicMessages(messages: AgentMessage[]): {
+  system: string;
+  messages: MessageParam[];
+} {
+  const system = messages
+    .filter((message) => message.role === "system")
+    .map((message) => message.content)
+    .join("\n\n");
+  const converted: MessageParam[] = [];
+  for (const message of messages) {
+    if (message.role === "system") continue;
+    if (message.role === "user") converted.push({ role: "user", content: message.content });
+    else if (message.role === "assistant")
+      converted.push({
+        role: "assistant",
+        content: [
+          ...(message.content ? [{ type: "text" as const, text: message.content }] : []),
+          ...message.toolCalls.map((call) => ({
+            type: "tool_use" as const,
+            id: call.callId,
+            name: call.name,
+            input: call.input,
+          })),
+        ],
+      });
+    else {
+      const block = {
+        type: "tool_result" as const,
+        tool_use_id: message.callId,
+        content: message.content,
+        is_error: message.isError,
+      };
+      const previous = converted.at(-1);
+      if (previous?.role === "user" && Array.isArray(previous.content)) {
+        previous.content = [...previous.content, block];
+      } else {
+        converted.push({ role: "user", content: [block] });
+      }
+    }
+  }
+  return { system, messages: converted };
+}