@agentsky/sky 2.10.0 → 2.11.0

package/dist/products.d.ts

@@ -85,6 +85,7 @@ declare const agentAddonsSchema: z.ZodObject<{
         "happyhorse.t2v": "happyhorse.t2v";
         "minimax.h3": "minimax.h3";
         "fish-audio.transcribe": "fish-audio.transcribe";
+        "code-review": "code-review";
         "exa.answer": "exa.answer";
         "googlemap.geocode": "googlemap.geocode";
         "googlemap.places": "googlemap.places";
@@ -224,6 +225,7 @@ declare const createProductAgentSchema: z.ZodObject<{
             "happyhorse.t2v": "happyhorse.t2v";
             "minimax.h3": "minimax.h3";
             "fish-audio.transcribe": "fish-audio.transcribe";
+            "code-review": "code-review";
             "exa.answer": "exa.answer";
             "googlemap.geocode": "googlemap.geocode";
             "googlemap.places": "googlemap.places";
@@ -363,6 +365,7 @@ declare const prepareProductSessionSchema: z.ZodObject<{
             "happyhorse.t2v": "happyhorse.t2v";
             "minimax.h3": "minimax.h3";
             "fish-audio.transcribe": "fish-audio.transcribe";
+            "code-review": "code-review";
             "exa.answer": "exa.answer";
             "googlemap.geocode": "googlemap.geocode";
             "googlemap.places": "googlemap.places";

package/dist/products.js

@@ -8,7 +8,8 @@ import {
   skillsArraySchema,
   systemMessageEventSchema,
   userMessageEventSchema
-} from "./chunk-5QRKU3BR.js";
+} from "./chunk-WC7GJSAJ.js";
+import "./chunk-MLKGABMK.js";
 
 // ../../packages/spec/src/compatibility.ts
 var capabilityInputsSchema = capabilitiesSchema;

package/dist/{src-RYECJN5I.js → src-HVCP3PPM.js}

@@ -1,7 +1,8 @@
 import {
   external_exports,
   messagePartSchema
-} from "./chunk-5QRKU3BR.js";
+} from "./chunk-WC7GJSAJ.js";
+import "./chunk-MLKGABMK.js";
 
 // ../../packages/chat/src/stream.ts
 async function* parseSseStream(body) {

package/dist/trace-MPGQYXNR.js

@@ -0,0 +1,367 @@
+import {
+  USER_AGENT,
+  configPath
+} from "./chunk-RWPPIEHH.js";
+import {
+  TRACE_CONTENT_SCOPES,
+  redactTraceText
+} from "./chunk-WC7GJSAJ.js";
+import "./chunk-MLKGABMK.js";
+
+// src/trace.ts
+import { randomBytes } from "crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+var SPOOL_MAX_BYTES = 32 * 1024 * 1024;
+var RETRY_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var BATCH_MAX = 256;
+function traceDir() {
+  return process.env.SKY_TRACE_DIR ?? join(dirname(configPath()), "trace");
+}
+var statePath = (dir) => join(dir, "current.json");
+var spoolPath = (dir) => join(dir, "spool.jsonl");
+var gapPath = (dir) => join(dir, "gaps.json");
+var lockPath = (dir) => join(dir, "spool.lock");
+var LOCK_WAIT_MS = 3e3;
+var LOCK_STALE_MS = 3e4;
+function withLock(dir, fn) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  for (; ; ) {
+    try {
+      mkdirSync(lockPath(dir));
+      break;
+    } catch {
+      const age = existsSync(lockPath(dir)) ? Date.now() - statSync(lockPath(dir)).mtimeMs : 0;
+      if (age > LOCK_STALE_MS) rmSync(lockPath(dir), { recursive: true, force: true });
+      else if (Date.now() > deadline) throw new Error("the trace spool is busy");
+      else Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    rmSync(lockPath(dir), { recursive: true, force: true });
+  }
+}
+function readState(dir = traceDir()) {
+  try {
+    return JSON.parse(readFileSync(statePath(dir), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeState(state, dir = traceDir()) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const tmp = `${statePath(dir)}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state), { mode: 384 });
+  renameSync(tmp, statePath(dir));
+}
+function clearState(dir = traceDir()) {
+  rmSync(statePath(dir), { force: true });
+}
+function stamp(state, events, now = /* @__PURE__ */ new Date()) {
+  return events.map((event) => {
+    const sequence = state.next_sequence++;
+    return { event_id: `${sequence}-${randomBytes(4).toString("hex")}`, sequence, source_time: now.toISOString(), coverage: "metadata_only", ...event };
+  });
+}
+function readGaps(dir) {
+  try {
+    return JSON.parse(readFileSync(gapPath(dir), "utf8"));
+  } catch {
+    return { dropped_full: 0, dropped_expired: 0, refused: 0 };
+  }
+}
+function addGap(dir, key, count) {
+  if (!count) return;
+  const gaps = readGaps(dir);
+  gaps[key] += count;
+  writeFileSync(gapPath(dir), JSON.stringify(gaps), { mode: 384 });
+}
+function append(dir, events, now, maxBytes) {
+  const size = existsSync(spoolPath(dir)) ? statSync(spoolPath(dir)).size : 0;
+  const lines = events.map((event) => `${JSON.stringify({ spooled_at: now, event })}
+`);
+  const bytes = lines.reduce((sum, line) => sum + Buffer.byteLength(line), 0);
+  if (size + bytes > maxBytes) {
+    addGap(dir, "dropped_full", events.length);
+    return 0;
+  }
+  appendFileSync(spoolPath(dir), lines.join(""), { mode: 384 });
+  return events.length;
+}
+function record(build, { dir = traceDir(), now = /* @__PURE__ */ new Date(), maxBytes = SPOOL_MAX_BYTES } = {}) {
+  return withLock(dir, () => {
+    const state = readState(dir);
+    if (!state) return 0;
+    const events = stamp(state, build(state), now);
+    if (!events.length) return 0;
+    writeState(state, dir);
+    return append(dir, events, now.getTime(), maxBytes);
+  });
+}
+function readSpool(dir) {
+  if (!existsSync(spoolPath(dir))) return [];
+  return readFileSync(spoolPath(dir), "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function settle(dir, done, now) {
+  withLock(dir, () => {
+    const keep = readSpool(dir).filter((entry) => !done.has(entry.event.event_id) && now - entry.spooled_at < RETRY_WINDOW_MS);
+    const tmp = `${spoolPath(dir)}.${process.pid}.tmp`;
+    writeFileSync(tmp, keep.map((entry) => `${JSON.stringify(entry)}
+`).join(""), { mode: 384 });
+    renameSync(tmp, spoolPath(dir));
+  });
+}
+function grantSender(state, timeoutMs = 1e4) {
+  return async (events) => {
+    const res = await fetch(`${state.api_base.replace(/\/$/, "")}/traces/${state.trace_id}/events`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${state.token}`, "content-type": "application/json", "user-agent": USER_AGENT },
+      body: JSON.stringify({ events }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (res.ok) return (await res.json()).results;
+    if (res.status >= 400 && res.status < 500 && res.status !== 408 && res.status !== 429) {
+      const code = await res.json().then((body) => body.error?.code ?? `http_${res.status}`, () => `http_${res.status}`);
+      throw new FinalRefusal(code, res.status);
+    }
+    throw new Error(`trace upload answered ${res.status}`);
+  };
+}
+var FinalRefusal = class extends Error {
+  constructor(code, status) {
+    super(`trace upload refused: ${code}`);
+    this.code = code;
+    this.status = status;
+  }
+  code;
+  status;
+};
+async function flush(send, { dir = traceDir(), now = Date.now(), attempts = 1, backoffMs = 500, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const all = readSpool(dir);
+  const fresh = all.filter((entry) => now - entry.spooled_at < RETRY_WINDOW_MS);
+  const expired = all.length - fresh.length;
+  addGap(dir, "dropped_expired", expired);
+  let pending = fresh;
+  let sent = 0;
+  let refused = 0;
+  let stopped;
+  const done = /* @__PURE__ */ new Set();
+  for (let attempt = 0; attempt < attempts && pending.length && !stopped; attempt++) {
+    if (attempt) await sleep(backoffMs * 2 ** (attempt - 1));
+    while (pending.length) {
+      const batch = pending.slice(0, BATCH_MAX);
+      let results;
+      try {
+        results = await send(batch.map((entry) => entry.event));
+      } catch (error) {
+        if (error instanceof FinalRefusal) stopped = error.code;
+        break;
+      }
+      for (const result of results) done.add(result.event_id);
+      refused += results.filter((result) => result.status === "refused").length;
+      sent += results.filter((result) => result.status !== "refused").length;
+      const settledNow = new Set(results.map((result) => result.event_id));
+      pending = [...batch.filter((entry) => !settledNow.has(entry.event.event_id)), ...pending.slice(BATCH_MAX)];
+      settle(dir, done, now);
+      if (settledNow.size === 0) break;
+    }
+  }
+  if (expired && !done.size) settle(dir, done, now);
+  addGap(dir, "refused", refused);
+  return { sent, refused, expired, pending: pending.length, ...stopped ? { stopped } : {} };
+}
+function spoolStatus(dir = traceDir()) {
+  return { pending: readSpool(dir).length, ...readGaps(dir) };
+}
+var SESSION_REF = /\bsess_[A-Za-z0-9]{8,48}\b/g;
+var startsCloudWork = (input) => Boolean(input.tool_name?.startsWith("mcp__agentsky")) || input.tool_name === "Bash" && /(^|[\s;&|(])(sky|npx\s+(-y\s+)?@agentsky\/sky)\s/.test(String(input.tool_input?.command ?? ""));
+function eventsForClaudeHook(input, state) {
+  if (!input.session_id) return [];
+  const span = `claude-code:${input.session_id}`;
+  const tool = input.tool_name ?? null;
+  const useId = input.tool_use_id ?? null;
+  switch (input.hook_event_name) {
+    case "SessionStart":
+      return [{ span_id: span, parent_span_id: state.root_span ?? null, kind: "start", name: "claude code session", attributes: { start: input.source ?? null } }];
+    case "UserPromptSubmit":
+      return [{ span_id: span, kind: "event", name: "turn.start" }];
+    case "Stop":
+      return [{ span_id: span, kind: "event", name: "turn.end" }];
+    case "SessionEnd":
+      return [{ span_id: span, kind: "end", name: "claude code session", outcome: "completed", attributes: { reason: input.reason ?? null } }];
+    case "PreToolUse":
+      if (tool === "Task" && useId) return [{ span_id: `claude-code:${useId}`, parent_span_id: span, kind: "start", name: "subagent" }];
+      return [{ span_id: span, kind: "event", name: "tool.start", attributes: { tool, tool_use_id: useId } }];
+    case "PostToolUse": {
+      if (tool === "Task" && useId) return [{ span_id: `claude-code:${useId}`, kind: "end", name: "subagent", outcome: "completed" }];
+      const events = [{ span_id: span, kind: "event", name: "tool.end", attributes: { tool, tool_use_id: useId } }];
+      if (startsCloudWork(input)) {
+        const named = new Set(JSON.stringify(input.tool_response ?? "").match(SESSION_REF) ?? []);
+        for (const session of named) {
+          events.push({ span_id: `cloud:${session}`, parent_span_id: span, kind: "start", name: "cloud session", session_id: session, attributes: { via: tool } });
+        }
+      }
+      return events;
+    }
+    default:
+      return [];
+  }
+}
+function claudeHooksConfig(command = "sky trace hook") {
+  const entry = [{ hooks: [{ type: "command", command, timeout: 10 }] }];
+  const matched = [{ matcher: "*", hooks: [{ type: "command", command, timeout: 10 }] }];
+  return {
+    SessionStart: entry,
+    UserPromptSubmit: entry,
+    PreToolUse: matched,
+    PostToolUse: matched,
+    Stop: entry,
+    SessionEnd: entry
+  };
+}
+function installClaudeHooks(settingsPath, command = "sky trace hook") {
+  const settings = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, "utf8")) : {};
+  const hooks = settings.hooks ?? {};
+  for (const [event, entries] of Object.entries(claudeHooksConfig(command))) {
+    const existing = (hooks[event] ?? []).filter((group) => !group.hooks?.some((hook) => hook.command === command));
+    hooks[event] = [...existing, ...entries];
+  }
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify({ ...settings, hooks }, null, 2)}
+`);
+  return settingsPath;
+}
+var FILE_READ_MAX_BYTES = 1024 * 1024;
+var FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Write", "Edit", "MultiEdit", "NotebookEdit"]);
+var CONTENT_ESCAPED_MAX_BYTES = 56 * 1024;
+var NEVER_READ = [
+  /(^|\/)\.env(\.|$)/,
+  /(^|\/)\.(ssh|aws|gnupg|docker|kube|gcloud|azure|password-store|git)\//,
+  /(^|\/)\.(netrc|npmrc|pypirc|pgpass|git-credentials)$/,
+  /\.(pem|key|p12|pfx|keystore|jks|kdbx)$/i,
+  /(^|\/)id_(rsa|dsa|ecdsa|ed25519)/,
+  /(^|\/)(credentials|secrets?)(\.[a-z]+)?$/i,
+  /cookies/i,
+  /(^|\/)\.(claude|codex|gemini|cursor)\//,
+  /Library\/Keychains\//
+];
+function parseContentScopes(value) {
+  if (!value) return [];
+  const scopes = [...new Set(value.split(",").map((part) => part.trim()).filter(Boolean))];
+  for (const scope of scopes) {
+    if (!TRACE_CONTENT_SCOPES.includes(scope)) throw new Error(`unknown capture scope ${scope} (use ${TRACE_CONTENT_SCOPES.join(", ")})`);
+  }
+  return scopes;
+}
+function realPath(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function fileAllowed(path, state) {
+  const real = realPath(path);
+  if (NEVER_READ.some((pattern) => pattern.test(real.split(sep).join("/")))) return false;
+  if (state.files?.includes(real)) return true;
+  return (state.dirs ?? []).some((dir) => {
+    const rel = relative(dir, real);
+    return rel !== "" && !rel.startsWith("..") && !rel.startsWith(sep);
+  });
+}
+function contentEvent(span, name, scope, text, extra = {}) {
+  try {
+    let safe = redactTraceText(text);
+    const escaped = Buffer.byteLength(JSON.stringify(safe.text));
+    if (escaped > CONTENT_ESCAPED_MAX_BYTES) {
+      const fitted = redactTraceText(text, Math.floor(Buffer.byteLength(safe.text) * (CONTENT_ESCAPED_MAX_BYTES / escaped)));
+      safe = { ...fitted, truncated: true };
+    }
+    return {
+      span_id: span,
+      kind: "event",
+      name,
+      coverage: safe.redactions ? "redacted" : safe.truncated ? "partial" : "complete",
+      content: { scope, text: safe.text, ...extra, ...safe.truncated ? { truncated: true } : {}, ...safe.redactions ? { redactions: safe.redactions } : {} }
+    };
+  } catch {
+    return { span_id: span, kind: "event", name, coverage: "metadata_only", attributes: { content_omitted: "redaction_failed" } };
+  }
+}
+function fileEvent(span, path, state) {
+  if (!state.content_scopes?.includes("files") || !fileAllowed(path, state)) return null;
+  try {
+    const real = realPath(path);
+    if (!statSync(real).isFile()) return null;
+    const bytes = readFileSync(real).subarray(0, FILE_READ_MAX_BYTES);
+    if (bytes.includes(0)) return null;
+    return contentEvent(span, "file", "files", bytes.toString("utf8"), { path: real });
+  } catch {
+    return null;
+  }
+}
+function contentForClaudeHook(input, state) {
+  const scopes = state.content_scopes ?? [];
+  if (!input.session_id || !scopes.length) return [];
+  const span = `claude-code:${input.session_id}`;
+  if (input.hook_event_name === "UserPromptSubmit") {
+    return scopes.includes("prompts") && input.prompt ? [contentEvent(span, "prompt", "prompts", input.prompt)] : [];
+  }
+  if (input.hook_event_name !== "PostToolUse") return [];
+  const events = [];
+  if (scopes.includes("tool_output") && input.tool_response !== void 0 && input.tool_name !== "Task") {
+    const text = typeof input.tool_response === "string" ? input.tool_response : JSON.stringify(input.tool_response);
+    const event = contentEvent(span, "tool.output", "tool_output", text);
+    events.push({ ...event, attributes: { ...event.attributes, tool: input.tool_name ?? null, tool_use_id: input.tool_use_id ?? null } });
+  }
+  const touched = input.tool_input;
+  const path = typeof touched?.file_path === "string" ? touched.file_path : typeof touched?.notebook_path === "string" ? touched.notebook_path : null;
+  if (path && FILE_TOOLS.has(input.tool_name ?? "")) {
+    const event = fileEvent(span, path, state);
+    if (event) events.push(event);
+  }
+  return events;
+}
+function chosenPaths(files, dirs) {
+  const check = (path, kind) => {
+    const real = realPath(path);
+    if (!existsSync(real)) throw new Error(`${path} does not exist`);
+    if (kind === "file" ? !statSync(real).isFile() : !statSync(real).isDirectory()) throw new Error(`${path} is not a ${kind}`);
+    if (kind === "file" && !fileAllowed(real, { files: [real] })) throw new Error(`${basename(path)} looks like a credential or agent-state file and is never captured`);
+    return real;
+  };
+  return { files: files.map((path) => check(path, "file")), dirs: dirs.map((path) => check(path, "folder")) };
+}
+export {
+  BATCH_MAX,
+  FinalRefusal,
+  RETRY_WINDOW_MS,
+  SPOOL_MAX_BYTES,
+  chosenPaths,
+  claudeHooksConfig,
+  clearState,
+  contentEvent,
+  contentForClaudeHook,
+  eventsForClaudeHook,
+  fileAllowed,
+  fileEvent,
+  flush,
+  grantSender,
+  installClaudeHooks,
+  parseContentScopes,
+  readState,
+  record,
+  spoolStatus,
+  stamp,
+  traceDir,
+  writeState
+};

package/dist/worker-6Q4K4HZW.js

@@ -0,0 +1,190 @@
+import "./chunk-MLKGABMK.js";
+
+// src/worker.ts
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { randomBytes } from "crypto";
+var RealDockerRunner = class {
+  async run({ image, envFile, port, signal }) {
+    const { spawn } = await import("child_process");
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        "docker",
+        [
+          "run",
+          "--rm",
+          "--pull=always",
+          `--env-file=${envFile}`,
+          `-p`,
+          `127.0.0.1:${port}:8080`,
+          image
+        ],
+        { stdio: "inherit" }
+      );
+      signal.addEventListener("abort", () => {
+        child.kill("SIGTERM");
+      });
+      child.on("error", reject);
+      child.on("exit", (code) => {
+        if (code === 0 || signal.aborted) resolve();
+        else reject(new Error(`docker exited with code ${code}`));
+      });
+    });
+  }
+};
+var POD_PORT = 18080;
+var HEARTBEAT_INTERVAL_MS = 15e3;
+async function startWorker(opts) {
+  const docker = opts.docker ?? new RealDockerRunner();
+  const signal = opts.signal ?? new AbortController().signal;
+  const wsUrl = opts.apiBase.replace(/^https?:\/\//, (m) => m === "https://" ? "wss://" : "ws://").replace(/\/$/, "");
+  const connectUrl = `${wsUrl}/api/v1/worker-pools/${opts.poolId}/connect`;
+  return new Promise((resolve, reject) => {
+    import("ws").then(({ default: WS }) => {
+      const ws = new WS(connectUrl, {
+        headers: { authorization: `Bearer ${opts.token}` }
+      });
+      let currentContainer = null;
+      const heartbeatTimer = setInterval(() => {
+        if (ws.readyState === WS.OPEN) {
+          ws.send(JSON.stringify({ type: "heartbeat" }));
+        }
+      }, HEARTBEAT_INTERVAL_MS);
+      signal.addEventListener("abort", () => {
+        clearInterval(heartbeatTimer);
+        currentContainer?.abort();
+        ws.close();
+        resolve();
+      });
+      ws.on("open", () => {
+        ws.send(JSON.stringify({
+          type: "hello",
+          label: opts.label,
+          imageDigest: "unknown",
+          capacity: 1
+        }));
+        console.log(`[sky worker] connected to pool ${opts.poolId}`);
+      });
+      ws.on("message", async (raw) => {
+        let msg;
+        try {
+          msg = JSON.parse(raw.toString());
+        } catch {
+          return;
+        }
+        if (msg.type === "start") {
+          await handleStart(msg, ws, WS, docker, currentContainer);
+        } else if (msg.type === "stop") {
+          currentContainer?.abort();
+          currentContainer = null;
+        } else if (msg.type === "http") {
+          await handleHttp(msg, ws);
+        } else if (msg.type === "stream_open") {
+          void handleStreamOpen(msg, ws);
+        }
+      });
+      ws.on("close", () => {
+        clearInterval(heartbeatTimer);
+        currentContainer?.abort();
+        resolve();
+      });
+      ws.on("error", (err) => {
+        clearInterval(heartbeatTimer);
+        currentContainer?.abort();
+        reject(err);
+      });
+    }).catch(reject);
+  });
+  async function handleStart(msg, ws, WS, docker2, existingContainer) {
+    if (existingContainer) existingContainer.abort();
+    const dir = join(tmpdir(), `sky-worker-${randomBytes(6).toString("hex")}`);
+    mkdirSync(dir, { mode: 448 });
+    const envFile = join(dir, "pod.env");
+    const envLines = Object.entries(msg.env).map(([k, v]) => `${k}=${v.replace(/\n/g, "\\n")}`).join("\n");
+    writeFileSync(envFile, envLines, { mode: 384 });
+    const containerAbort = new AbortController();
+    try {
+      void docker2.run({
+        image: msg.image,
+        envFile,
+        port: POD_PORT,
+        signal: containerAbort.signal
+      }).finally(() => {
+        try {
+          rmSync(dir, { recursive: true });
+        } catch {
+        }
+      });
+    } catch (err) {
+      try {
+        rmSync(dir, { recursive: true });
+      } catch {
+      }
+      console.error("[sky worker] docker run failed:", err);
+    }
+  }
+  async function handleHttp(msg, ws) {
+    const url = `http://127.0.0.1:${POD_PORT}${msg.path}`;
+    try {
+      const response = await fetch(url, {
+        method: msg.method,
+        headers: msg.headers,
+        body: msg.body || void 0,
+        signal: AbortSignal.timeout(3e4)
+      });
+      const body = await response.text();
+      const headers = {};
+      response.headers.forEach((v, k) => {
+        headers[k] = v;
+      });
+      const resp = {
+        type: "http_response",
+        id: msg.id,
+        status: response.status,
+        headers,
+        body
+      };
+      ws.send(JSON.stringify(resp));
+    } catch (err) {
+      ws.send(JSON.stringify({
+        type: "http_response",
+        id: msg.id,
+        status: 502,
+        headers: {},
+        body: String(err)
+      }));
+    }
+  }
+  async function handleStreamOpen(msg, ws) {
+    const url = `http://127.0.0.1:${POD_PORT}${msg.path}`;
+    try {
+      const response = await fetch(url, {
+        headers: { accept: "text/event-stream" },
+        signal: AbortSignal.timeout(3e5)
+      });
+      const reader = response.body?.getReader();
+      if (!reader) {
+        ws.send(JSON.stringify({ type: "stream_close", id: msg.id }));
+        return;
+      }
+      const decoder = new TextDecoder();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        ws.send(JSON.stringify({
+          type: "stream_event",
+          id: msg.id,
+          data: decoder.decode(value, { stream: true })
+        }));
+      }
+      ws.send(JSON.stringify({ type: "stream_close", id: msg.id }));
+    } catch {
+      ws.send(JSON.stringify({ type: "stream_close", id: msg.id }));
+    }
+  }
+}
+export {
+  RealDockerRunner,
+  startWorker
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentsky/sky",
-  "version": "2.10.0",
-  "description": "sky — the AgentSky developer CLI: launch and talk to long-lived agents from your terminal.",
+  "version": "2.11.0",
+  "description": "sky \u2014 the AgentSky developer CLI: launch and talk to long-lived agents from your terminal.",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -22,7 +22,8 @@
   "dependencies": {
     "commander": "^14.0.0",
     "smol-toml": "^1.4.2",
-    "zod": "4.5.4"
+    "zod": "4.5.4",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@agent/chat": "*",