@agentsky/sky 2.10.0 → 2.12.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";
@@ -94,6 +95,8 @@ declare const agentAddonsSchema: z.ZodObject<{
         "meta.transcribe": "meta.transcribe";
         "minimax.tts": "minimax.tts";
         "elevenlabs.sound": "elevenlabs.sound";
+        "elevenlabs.tts": "elevenlabs.tts";
+        "elevenlabs.music": "elevenlabs.music";
         "zai.transcribe": "zai.transcribe";
         "openai.transcribe": "openai.transcribe";
         "fish-audio.tts": "fish-audio.tts";
@@ -224,6 +227,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";
@@ -233,6 +237,8 @@ declare const createProductAgentSchema: z.ZodObject<{
             "meta.transcribe": "meta.transcribe";
             "minimax.tts": "minimax.tts";
             "elevenlabs.sound": "elevenlabs.sound";
+            "elevenlabs.tts": "elevenlabs.tts";
+            "elevenlabs.music": "elevenlabs.music";
             "zai.transcribe": "zai.transcribe";
             "openai.transcribe": "openai.transcribe";
             "fish-audio.tts": "fish-audio.tts";
@@ -363,6 +369,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";
@@ -372,6 +379,8 @@ declare const prepareProductSessionSchema: z.ZodObject<{
             "meta.transcribe": "meta.transcribe";
             "minimax.tts": "minimax.tts";
             "elevenlabs.sound": "elevenlabs.sound";
+            "elevenlabs.tts": "elevenlabs.tts";
+            "elevenlabs.music": "elevenlabs.music";
             "zai.transcribe": "zai.transcribe";
             "openai.transcribe": "openai.transcribe";
             "fish-audio.tts": "fish-audio.tts";

package/dist/products.js

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

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

@@ -1,7 +1,8 @@
 import {
   external_exports,
   messagePartSchema
-} from "./chunk-5QRKU3BR.js";
+} from "./chunk-XXDQKVPS.js";
+import "./chunk-MLKGABMK.js";
 
 // ../../packages/chat/src/stream.ts
 async function* parseSseStream(body) {
@@ -96,6 +97,16 @@ var internalEventSchema = external_exports.object({
    *  session.deleted) — emitted verbatim; the host already persisted it. */
   lifecycle: external_exports.object({ id: external_exports.string().min(1), type: external_exports.string().min(1) }).passthrough().optional()
 });
+function personalContextForPod(body, supported) {
+  const { personal_context: grant, ...rest } = body;
+  if (!grant || supported) return body;
+  const text = `This runtime cannot receive the private personal-context credential file. Use this value instead, as X-Personal-Context on memory and context API requests and as ACTL_PERSONAL_CONTEXT for actl grep: ${grant}. Never print, persist or share it.`;
+  const parts = [...rest.parts, { type: "text", index: Math.max(-1, ...rest.parts.map((part) => part.index)) + 1, text }];
+  if (!rest.events) return { ...rest, parts };
+  const previous = rest.events.find((event) => event.type === "system.message");
+  const system = { type: "system.message", content: [{ type: "text", text: [...previous?.type === "system.message" ? previous.content.map((block) => block.text) : [], text].join("\n\n") }] };
+  return { ...rest, parts, events: [...rest.events.filter((event) => event.type !== "system.message"), system] };
+}
 function podMessageBody(messageId, turn, resourcesRevision = 0) {
   if ("events" in turn) {
     const envelope = {
@@ -143,6 +154,7 @@ function classifyPodSendStatus(status, detail) {
   if (status >= 500) return { kind: "uncertain", reason: "server_error", status, detail };
   return { kind: "rejected", status, detail };
 }
+var PERSONAL_CONTEXT_PODS = /* @__PURE__ */ new Set();
 async function sendPodMessage(baseUrl, body, options = {}) {
   const headers = {
     "content-type": "application/json",
@@ -151,6 +163,11 @@ async function sendPodMessage(baseUrl, body, options = {}) {
   if (options.idempotencyKey) headers["idempotency-key"] = options.idempotencyKey;
   let res;
   try {
+    if (body.personal_context && !PERSONAL_CONTEXT_PODS.has(baseUrl)) {
+      const health = await getPodHealth(baseUrl, options);
+      if (health.personalContext) PERSONAL_CONTEXT_PODS.add(baseUrl);
+      else if (health.ok) body = personalContextForPod(body, false);
+    }
     const user = body.events?.find((event) => event.type === "user.message");
     const mode = user?.type === "user.message" ? user.interaction_mode : body.interaction_mode;
     if (mode) {
@@ -196,7 +213,8 @@ async function getPodHealth(baseUrl, options = {}) {
       status: res.status,
       state: typeof body.state === "string" ? body.state : void 0,
       openMessageId: typeof open === "string" && open ? open : null,
-      interactionModes: Array.isArray(body.interaction_modes) ? body.interaction_modes.filter((mode) => mode === "plan" || mode === "build") : void 0
+      interactionModes: Array.isArray(body.interaction_modes) ? body.interaction_modes.filter((mode) => mode === "plan" || mode === "build") : void 0,
+      personalContext: body.personal_context === true
     };
   } catch {
     return { ok: false, openMessageId: null };
@@ -294,6 +312,7 @@ export {
   interruptSession,
   legacyPartsOf,
   parseSseStream,
+  personalContextForPod,
   podMessageBody,
   postSessionEvents,
   sendPodMessage,

package/dist/trace-UJTFSXNM.js

@@ -0,0 +1,367 @@
+import {
+  USER_AGENT,
+  configPath
+} from "./chunk-RF5JICNX.js";
+import {
+  TRACE_CONTENT_SCOPES,
+  redactTraceText
+} from "./chunk-XXDQKVPS.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
+};