@standardagents/code 0.0.0-dev.fffff → 0.0.2-dev.517db40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardagents/code",
-  "version": "0.0.0-dev.fffff",
+  "version": "0.0.2-dev.517db40",
   "description": "Standard Code — a terminal coding agent whose LLM loop runs on a Standard Agents instance while its tools execute on your machine via this CLI.",
   "type": "module",
   "license": "UNLICENSED",
@@ -14,15 +14,15 @@
     "registry": "https://registry.npmjs.org/"
   },
   "bin": {
-    "standardcode": "./bin/standardcode.mjs"
+    "standardcode": "dist/index.js"
   },
   "files": [
-    "bin",
-    "src"
+    "dist"
   ],
   "scripts": {
     "start": "tsx src/index.ts",
     "code": "tsx src/index.ts",
+    "build": "tsup",
     "release": "node scripts/release.mjs",
     "release:next": "node scripts/release.mjs --tag=next",
     "release:dev": "node scripts/release.mjs --tag=dev",
@@ -32,6 +32,7 @@
   "devDependencies": {
     "@clack/prompts": "^1.6.0",
     "@types/node": "^22.10.0",
+    "tsup": "^8.5.1",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3"
   }

package/bin/standardcode.mjs

@@ -1,25 +0,0 @@
-#!/usr/bin/env node
-// Launcher for the Standard Code CLI. Runs the TypeScript entry through tsx so
-// it works without a separate build step during local development.
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import path from "node:path";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const entry = path.resolve(here, "../src/index.ts");
-const require = createRequire(import.meta.url);
-
-let tsxBin;
-try {
-  // Resolve tsx's CLI entry from wherever it is installed in the workspace.
-  tsxBin = require.resolve("tsx/cli");
-} catch {
-  console.error("Could not find 'tsx'. Run `pnpm install` in the workspace.");
-  process.exit(1);
-}
-
-const child = spawn(process.execPath, [tsxBin, entry, ...process.argv.slice(2)], {
-  stdio: "inherit",
-});
-child.on("exit", (code) => process.exit(code ?? 0));

package/src/api.ts

@@ -1,169 +0,0 @@
-/** Minimal REST client for the Standard Agents instance. */
-import type { ThreadSummary } from "./types.ts";
-
-export class ApiClient {
-  constructor(
-    private endpoint: string,
-    private token: string
-  ) {}
-
-  get wsEndpoint(): string {
-    return this.endpoint.replace(/^http/, "ws");
-  }
-
-  /** The instance origin (used to build admin-UI links). */
-  get origin(): string {
-    return this.endpoint;
-  }
-
-  get bearer(): string {
-    return this.token;
-  }
-
-  private async json<T>(pathname: string, init?: RequestInit): Promise<T> {
-    const res = await fetch(`${this.endpoint}${pathname}`, {
-      ...init,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.token}`,
-        ...(init?.headers || {}),
-      },
-    });
-    const text = await res.text();
-    if (!res.ok) {
-      throw new Error(`${init?.method || "GET"} ${pathname} -> ${res.status}: ${text.slice(0, 300)}`);
-    }
-    try {
-      return JSON.parse(text) as T;
-    } catch {
-      return text as unknown as T;
-    }
-  }
-
-  async verify(): Promise<boolean> {
-    try {
-      await this.json("/api/auth/me");
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /** Agent name → display title map (best effort; for labeling subagents). */
-  async listAgents(): Promise<{ name: string; title: string }[]> {
-    const res = await this.json<{ agents?: any[] } | any[]>("/api/agents");
-    const arr = Array.isArray(res) ? res : res.agents || [];
-    return arr
-      .filter((a) => a && typeof a.name === "string")
-      .map((a) => ({ name: a.name, title: typeof a.title === "string" ? a.title : a.name }));
-  }
-
-  async createThread(agentId: string, tags: string[]): Promise<string> {
-    const res = await this.json<{ threadId?: string; id?: string }>("/api/threads", {
-      method: "POST",
-      body: JSON.stringify({ agent_id: agentId, tags }),
-    });
-    const id = res.threadId || res.id;
-    if (!id) throw new Error("Thread create returned no id");
-    return id;
-  }
-
-  /** List threads for an agent, optionally filtering to those carrying all given tags. */
-  async listThreads(agentId: string, requireTags: string[]): Promise<ThreadSummary[]> {
-    const res = await this.json<{ threads?: any[] } | any[]>(
-      `/api/threads?agent_id=${encodeURIComponent(agentId)}&limit=100`
-    );
-    const arr = Array.isArray(res) ? res : res.threads || [];
-    return arr
-      .map((t) => ({
-        id: t.id,
-        tags: Array.isArray(t.tags) ? t.tags : [],
-        created_at: t.created_at,
-        title: t.title,
-        preview: t.preview || t.last_message,
-      }))
-      .filter((t: ThreadSummary) => requireTags.every((tag) => t.tags.includes(tag)));
-  }
-
-  async sendMessage(threadId: string, content: string): Promise<void> {
-    await this.json(`/api/threads/${threadId}/messages`, {
-      method: "POST",
-      body: JSON.stringify({ role: "user", content }),
-    });
-  }
-
-  async getMessages(threadId: string, limit = 50): Promise<any[]> {
-    const res = await this.json<{ messages?: any[] } | any[]>(
-      `/api/threads/${threadId}/messages?limit=${limit}`
-    );
-    return Array.isArray(res) ? res : res.messages || [];
-  }
-
-  async getLogs(threadId: string, limit = 100): Promise<any[]> {
-    const res = await this.json<{ logs?: any[] } | any[]>(
-      `/api/threads/${threadId}/logs?limit=${limit}&order=desc`
-    );
-    return Array.isArray(res) ? res : res.logs || [];
-  }
-
-  /**
-   * Deliver a durable forwarded tool result to the thread, resuming the turn.
-   * Retries with backoff — this is the durable delivery path, so it must land
-   * even if the connection is briefly flaky after a permission wait.
-   */
-  async postToolResult(
-    threadId: string,
-    toolCallId: string,
-    ok: boolean,
-    result?: string,
-    error?: string
-  ): Promise<boolean> {
-    const body = JSON.stringify({ tool_call_id: toolCallId, ok, result, error });
-    for (let attempt = 0; attempt < 6; attempt++) {
-      try {
-        await this.json(`/api/threads/${threadId}/tool-result`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body,
-        });
-        return true;
-      } catch {
-        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8000)));
-      }
-    }
-    return false;
-  }
-
-  /** Read a value from the thread's durable KV store (null if absent). */
-  async kvGet(threadId: string, key: string): Promise<unknown> {
-    try {
-      const res = await this.json<{ value?: unknown }>(
-        `/api/threads/${threadId}/kv?key=${encodeURIComponent(key)}`
-      );
-      return res?.value ?? null;
-    } catch {
-      return null; // 404 = key not yet set
-    }
-  }
-
-  /** Write a value to the thread's durable KV store. */
-  async kvSet(threadId: string, key: string, value: unknown): Promise<void> {
-    try {
-      await this.json(`/api/threads/${threadId}/kv`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ key, value }),
-      });
-    } catch {
-      // best effort
-    }
-  }
-
-  async stop(threadId: string): Promise<void> {
-    try {
-      await this.json(`/api/threads/${threadId}/stop`, { method: "POST" });
-    } catch {
-      // best effort
-    }
-  }
-}

package/src/approvals.ts

@@ -1,42 +0,0 @@
-/**
- * Session approvals — the permission mode plus the tools and risk levels the
- * user has pre-approved — persisted in the THREAD's KV store (server-side), so
- * they resume with the session and a server hook can show the agent what's
- * already approved. Nothing is stored on the client.
- */
-import type { ApiClient } from "./api.ts";
-import type { PermissionState } from "./permissions.ts";
-import type { Level } from "./types.ts";
-
-const KEY = "approvals";
-
-export interface ApprovalsKV {
-  level?: Level;
-  allowTools: string[];
-  allowRisk: number[];
-}
-
-export async function loadApprovals(api: ApiClient, threadId: string): Promise<ApprovalsKV> {
-  const v = await api.kvGet(threadId, KEY);
-  if (v && typeof v === "object" && !Array.isArray(v)) {
-    const o = v as Record<string, unknown>;
-    const n = Number(o.level);
-    const level = n >= 1 && n <= 5 ? (n as Level) : undefined;
-    return {
-      level,
-      allowTools: Array.isArray(o.allowTools) ? (o.allowTools as string[]) : [],
-      allowRisk: Array.isArray(o.allowRisk) ? (o.allowRisk as number[]) : [],
-    };
-  }
-  return { allowTools: [], allowRisk: [] };
-}
-
-/** Persist the current approvals to the thread KV (fire-and-forget). */
-export function saveApprovals(api: ApiClient, threadId: string, perm: PermissionState): void {
-  const payload: ApprovalsKV = {
-    level: perm.level,
-    allowTools: Array.from(perm.alwaysAllow).sort(),
-    allowRisk: Array.from(perm.allowRisk).sort((a, b) => a - b),
-  };
-  void api.kvSet(threadId, KEY, payload);
-}

package/src/bridge.ts

@@ -1,303 +0,0 @@
-/**
- * The client-tool bridge: holds a WebSocket open to the instance, receives
- * forwarded tool requests, runs them through the permission engine + safety
- * guard, executes the approved ones on the host, and returns results.
- */
-import type { ApiClient } from "./api.ts";
-import type { HostTools } from "./host-tools.ts";
-import { decide, isCatastrophic, type PermissionState } from "./permissions.ts";
-import { saveApprovals } from "./approvals.ts";
-import type { ToolRequest } from "./types.ts";
-
-export type ApprovalChoice = "allow" | "deny" | "always" | "always_risk";
-
-export type ConnectionState = "connected" | "reconnecting" | "reconnected";
-
-export interface BridgeHooks {
-  /** Print a permanent line (a finished/denied/blocked tool). */
-  onActivity(line: string): void;
-  /** Update the live working status (the currently-running tool, or null = idle). */
-  onStatus?(label: string | null): void;
-  /** Report connection lifecycle so the UI can show disconnect/reconnect state. */
-  onConnection?(state: ConnectionState, attempt: number): void;
-  /** Ask the user to approve a tool; resolve with their choice. */
-  requestApproval(req: ToolRequest, summary: string, effectiveRisk: number): Promise<ApprovalChoice>;
-}
-
-/** Tools that mutate or execute (used to deny in plan mode cleanly). */
-const PATH_ARG_TOOLS = new Set(["read_file", "list_dir", "grep", "glob", "write_file", "edit_file", "delete"]);
-
-export class Bridge {
-  private ws: WebSocket | null = null;
-  private closed = false;
-  private heartbeat: ReturnType<typeof setInterval> | null = null;
-  private reconnectAttempt = 0;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-  private resolveConnected: (() => void) | null = null;
-  // Durable forwarded calls we've started handling, so a server re-send (after a
-  // reconnect) doesn't prompt or run them twice.
-  private handledDurable = new Set<string>();
-
-  constructor(
-    private api: ApiClient,
-    private threadId: string,
-    private host: HostTools,
-    private perm: PermissionState,
-    private hooks: BridgeHooks
-  ) {}
-
-  /**
-   * Connect and keep the bridge connected. Resolves on the first successful
-   * open; thereafter any drop is reconnected automatically with exponential
-   * backoff (disconnections are expected — e.g. a dev-server reload — so this
-   * must be rock solid). A short safety timeout resolves startup even if the
-   * very first attempt is slow, since reconnection continues in the background.
-   */
-  connect(): Promise<void> {
-    return new Promise((resolve) => {
-      let settled = false;
-      this.resolveConnected = () => {
-        if (!settled) {
-          settled = true;
-          resolve();
-        }
-      };
-      // Don't hang startup forever if the first attempt is slow.
-      setTimeout(() => this.resolveConnected?.(), 8000);
-      this.openSocket();
-    });
-  }
-
-  private openSocket(): void {
-    if (this.closed) return;
-    const url = `${this.api.wsEndpoint}/api/threads/${this.threadId}/bridge?token=${encodeURIComponent(this.api.bearer)}`;
-    let ws: WebSocket;
-    try {
-      ws = new WebSocket(url);
-    } catch {
-      this.scheduleReconnect();
-      return;
-    }
-    this.ws = ws;
-
-    ws.addEventListener("open", () => {
-      const wasReconnecting = this.reconnectAttempt > 0;
-      this.reconnectAttempt = 0;
-      this.startHeartbeat(ws);
-      this.hooks.onConnection?.(wasReconnecting ? "reconnected" : "connected", 0);
-      this.resolveConnected?.();
-    });
-
-    ws.addEventListener("message", (ev) => this.onMessage(String((ev as MessageEvent).data)));
-
-    // A socket that fails to open fires 'error' but may never fire 'close', so
-    // both must drive reconnection. handleDrop dedupes via the current-socket check.
-    ws.addEventListener("error", () => this.handleDrop(ws));
-    ws.addEventListener("close", () => this.handleDrop(ws));
-  }
-
-  private handleDrop(ws: WebSocket): void {
-    if (this.ws !== ws) return; // stale event from a superseded socket
-    this.ws = null;
-    this.stopHeartbeat();
-    this.scheduleReconnect();
-  }
-
-  private scheduleReconnect(): void {
-    if (this.closed || this.reconnectTimer) return;
-    this.reconnectAttempt++;
-    this.hooks.onConnection?.("reconnecting", this.reconnectAttempt);
-    // Exponential backoff with jitter, capped — keep trying indefinitely.
-    const base = Math.min(500 * 2 ** (this.reconnectAttempt - 1), 15000);
-    const delay = base + Math.floor(Math.random() * 400);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.openSocket();
-    }, delay);
-  }
-
-  private startHeartbeat(ws: WebSocket): void {
-    this.stopHeartbeat();
-    // Heartbeat so the server can tell a live client (mid-build or awaiting an
-    // approval) from a dead one and never freeze a thread on us.
-    this.heartbeat = setInterval(() => {
-      try {
-        if (ws.readyState === WebSocket.OPEN) ws.send("ping");
-      } catch {
-        // ignore
-      }
-    }, 5000);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeat) {
-      clearInterval(this.heartbeat);
-      this.heartbeat = null;
-    }
-  }
-
-  close(): void {
-    this.closed = true;
-    this.stopHeartbeat();
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    this.ws?.close();
-  }
-
-  private send(payload: object): void {
-    try {
-      this.ws?.send(JSON.stringify(payload));
-    } catch {
-      // socket gone; the server will time the call out
-    }
-  }
-
-  private async onMessage(raw: string): Promise<void> {
-    let msg: any;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (msg.type !== "tool_request") return;
-    const req = msg as ToolRequest;
-    await this.handleToolRequest(req);
-  }
-
-  /**
-   * Reply to a tool request. Durable calls (the agent parked them) deliver the
-   * result over HTTP so it lands even if this socket later drops; legacy calls
-   * reply over the WebSocket.
-   */
-  private respond(req: ToolRequest, ok: boolean, result?: string, error?: string): void {
-    if (req.durable && req.toolCallId) {
-      void this.api.postToolResult(this.threadId, req.toolCallId, ok, result, error);
-    } else {
-      this.send({ type: "tool_response", id: req.id, ok, result, error });
-    }
-  }
-
-  private async handleToolRequest(req: ToolRequest): Promise<void> {
-    // Durable calls may be re-sent by the server after a reconnect — only handle
-    // each once (prompt + run), so the user isn't asked twice.
-    if (req.durable && req.toolCallId) {
-      if (this.handledDurable.has(req.toolCallId)) return;
-      this.handledDurable.add(req.toolCallId);
-    }
-
-    const summary = describe(req);
-
-    // Compute an effective risk, escalating anything that touches paths outside
-    // the project directory (the agent is told to stay inside it).
-    let effectiveRisk = typeof req.risk === "number" ? req.risk : req.requestPermission ? 3 : 1;
-    if (PATH_ARG_TOOLS.has(req.tool) && this.host.isOutsideProject(req.args.path as string | undefined)) {
-      effectiveRisk = Math.max(effectiveRisk, 4);
-    }
-
-    // Hard safety: never run catastrophic shell commands, even in bypass mode.
-    if (req.tool === "bash" && isCatastrophic(String(req.args.command || ""))) {
-      this.hooks.onActivity(`⛔ blocked dangerous command: ${summary}`);
-      this.respond(req, false, undefined, "Blocked: this command is considered catastrophic and was refused by the client safety guard.");
-      return;
-    }
-
-    // Permission key: normally the tool name, but MCP calls are gated at the
-    // finer `mcp:<server>/<tool>` granularity so "always allow this tool" approves
-    // one server's tool rather than every MCP call.
-    const permKey = permissionKey(req);
-    const decision = decide(this.perm, permKey, effectiveRisk, !!req.requestPermission);
-
-    if (decision === "deny") {
-      this.hooks.onActivity(`⛔ ${summary} — blocked (risk ${effectiveRisk})`);
-      this.respond(req, false, undefined, `Denied by policy (risk ${effectiveRisk}).`);
-      return;
-    }
-
-    if (decision === "ask") {
-      const choice = await this.hooks.requestApproval(req, summary, effectiveRisk);
-      if (choice === "deny") {
-        this.hooks.onActivity(`⛔ ${summary} — you declined`);
-        this.respond(req, false, undefined, "The user declined to run this operation.");
-        return;
-      }
-      if (choice === "always") this.perm.alwaysAllow.add(permKey);
-      if (choice === "always_risk") this.perm.allowRisk.add(effectiveRisk);
-      if (choice === "always" || choice === "always_risk") {
-        saveApprovals(this.api, this.threadId, this.perm);
-      }
-    }
-
-    // Show the running tool in the live status, then leave a permanent line.
-    this.hooks.onStatus?.(summary);
-    const result = await this.host.execute(req.tool, req.args);
-    this.hooks.onStatus?.(null);
-    if (result.ok) {
-      this.hooks.onActivity(`✓ ${summary}${detailSuffix(req.tool, result.result)}`);
-      this.respond(req, true, result.result ?? "");
-    } else {
-      this.hooks.onActivity(`✗ ${summary} — ${result.error}`);
-      this.respond(req, false, undefined, result.error);
-    }
-  }
-}
-
-/**
- * Stable permission key for a request. For MCP, gate on the specific server +
- * tool/resource so approvals are fine-grained; for everything else, the tool name.
- */
-export function permissionKey(req: ToolRequest): string {
-  if (req.tool !== "mcp") return req.tool;
-  const a = req.args;
-  const server = String(a.server || "?");
-  const action = String(a.action || "call");
-  if (action === "read_resource") return `mcp:${server}/resource`;
-  if (action === "list_tools") return `mcp:${server}/list`;
-  return `mcp:${server}/${String(a.tool || "?")}`;
-}
-
-/** One-line human summary of a tool request for the activity feed. */
-export function describe(req: ToolRequest): string {
-  const a = req.args;
-  switch (req.tool) {
-    case "mcp": {
-      const server = String(a.server || "?");
-      const action = String(a.action || "call");
-      if (action === "list_tools") return `mcp ${server}: list tools`;
-      if (action === "read_resource") return `mcp ${server}: read ${a.uri}`;
-      return `mcp ${server}: ${a.tool}`;
-    }
-    case "read_file":
-      return `read ${a.path}`;
-    case "list_dir":
-      return `list ${a.path || "."}`;
-    case "grep":
-      return `grep "${a.pattern}"${a.glob ? ` in ${a.glob}` : ""}`;
-    case "glob":
-      return `find ${a.pattern}`;
-    case "write_file":
-      return `write ${a.path}`;
-    case "edit_file":
-      return `edit ${a.path}`;
-    case "delete":
-      return `delete ${a.path}`;
-    case "bash":
-      return `bash: ${String(a.command).slice(0, 80)}`;
-    default:
-      return `${req.tool} ${JSON.stringify(a).slice(0, 80)}`;
-  }
-}
-
-/** A short parenthetical hint appended to a finished read-style tool line. */
-function detailSuffix(tool: string, result?: string): string {
-  if (!result) return "";
-  // Mutations already read clearly from their summary; don't pile on.
-  if (tool === "write_file" || tool === "edit_file" || tool === "delete") return "";
-  if (tool === "bash") {
-    const m = result.match(/\[exit code (\d+)\]\s*$/);
-    return m ? ` (exit ${m[1]})` : "";
-  }
-  const lines = result.split("\n").length;
-  return ` (${lines} line${lines === 1 ? "" : "s"})`;
-}

package/src/credentials.ts

@@ -1,49 +0,0 @@
-/** Read/write ~/.standardagents/credentials. */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import type { CredentialsFile, InstanceCredential } from "./types.ts";
-
-const DIR = path.join(os.homedir(), ".standardagents");
-const FILE = path.join(DIR, "credentials");
-
-export function normalizeEndpoint(endpoint: string): string {
-  let e = endpoint.trim();
-  if (!/^https?:\/\//i.test(e)) e = "http://" + e;
-  return e.replace(/\/+$/, "");
-}
-
-export function loadCredentials(): CredentialsFile {
-  try {
-    const raw = fs.readFileSync(FILE, "utf8");
-    const parsed = JSON.parse(raw) as CredentialsFile;
-    if (!parsed.instances) parsed.instances = {};
-    return parsed;
-  } catch {
-    return { instances: {} };
-  }
-}
-
-export function getCredential(endpoint: string): InstanceCredential | null {
-  const creds = loadCredentials();
-  return creds.instances[normalizeEndpoint(endpoint)] ?? null;
-}
-
-export function saveCredential(cred: InstanceCredential): void {
-  const creds = loadCredentials();
-  const endpoint = normalizeEndpoint(cred.endpoint);
-  creds.instances[endpoint] = { ...cred, endpoint };
-  creds.default_endpoint = endpoint;
-  fs.mkdirSync(DIR, { recursive: true });
-  // Credentials contain a bearer token — keep them private.
-  fs.writeFileSync(FILE, JSON.stringify(creds, null, 2), { mode: 0o600 });
-  try {
-    fs.chmodSync(FILE, 0o600);
-  } catch {
-    // best effort on platforms without chmod
-  }
-}
-
-export function defaultEndpoint(): string | null {
-  return loadCredentials().default_endpoint ?? null;
-}