@agentsky/sky 2.7.3 → 2.8.0

package/dist/{chunk-IC4N2ZPL.js → chunk-WFTZR5YO.js}

@@ -19028,6 +19028,7 @@ var REASONING_EFFORTS = {
   code_assistant: null,
   docker_cagent: null,
   kiro: null,
+  muse_code: null,
   openhands: null,
   hermes: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
   claude_code: ["low", "medium", "high", "xhigh", "max"],
@@ -19339,6 +19340,13 @@ var ACP_AGENTS = {
     "version": "2.22.0",
     "website": "https://kiro.dev/docs/cli/acp/"
   },
+  "muse_code": {
+    "registryId": "muse-code",
+    "label": "Muse Code",
+    "description": "Meta's coding agent and CLI",
+    "version": "1.4.3",
+    "website": "https://dev.meta.ai/docs/muse-code/"
+  },
   "openhands": {
     "registryId": "openhands",
     "label": "OpenHands",
@@ -19388,7 +19396,8 @@ var ACP_AGENT_TYPES = [
   "code_assistant",
   "docker_cagent",
   "kiro",
-  "openhands"
+  "openhands",
+  "muse_code"
 ];
 function isAcpAgentType(value) {
   return Object.hasOwn(ACP_AGENTS, value);
@@ -20891,6 +20900,35 @@ var ACP_ACCOUNT_PROFILES = {
       "https://kiro.dev/docs/getting-started/authentication/"
     ]
   },
+  "muse_code": {
+    "name": "Muse Code",
+    "version": "1.4.3",
+    "status": "documented",
+    "setupModes": [
+      {
+        "id": "api_key",
+        "label": "API key",
+        "fields": [
+          {
+            "key": "META_API_KEY",
+            "label": "Meta API key",
+            "kind": "secret",
+            "required": true,
+            "source": "https://dev.meta.ai/docs/muse-code/"
+          }
+        ],
+        "source": "https://dev.meta.ai/docs/muse-code/"
+      }
+    ],
+    "files": [],
+    "notes": [
+      "Muse Code runs through a community ACP adapter in front of Meta's own host binary. An authenticated turn has not been exercised."
+    ],
+    "sources": [
+      "https://dev.meta.ai/docs/muse-code/",
+      "https://github.com/bex-co/muse-code-acp"
+    ]
+  },
   "openhands": {
     "name": "OpenHands",
     "version": "1.16.0",
@@ -21935,6 +21973,7 @@ var GATEWAY_CAPABILITY_IDS = [
   "wan.image"
 ];
 var CAPABILITY_IDS = [...LEGACY_CAPABILITY_IDS, ...GATEWAY_CAPABILITY_IDS];
+var PLATFORM_CAPABILITY_IDS = ["platform.orchestration"];
 var allowedLlms = {
   jev: ["typesafe/jev-1.13"],
   agoragentic_acp: ["harness-default"],
@@ -21977,6 +22016,7 @@ var allowedLlms = {
   code_assistant: [...ACP_PLATFORM_MODELS.code_assistant, "harness-default"],
   docker_cagent: [...ACP_PLATFORM_MODELS.docker_cagent, "harness-default"],
   kiro: ["harness-default"],
+  muse_code: ["harness-default"],
   openhands: [...ACP_PLATFORM_MODELS.openhands, "harness-default"],
   hermes: [
     "deepseek-v4-pro",
@@ -22177,19 +22217,22 @@ function modelSubscriptionProviderFor(agentType, llm) {
   if (agentType === "codex" && CHATGPT_PLAN_MODELS.has(llm)) return "openai";
   if (agentType === "cursor" && llm === "harness-default") return "cursor";
   if (agentType === "grok_build" && llm === "harness-default") return "xai";
+  if (agentType === "muse_code" && llm === "harness-default") return "meta";
   return null;
 }
 var MODEL_SUBSCRIPTION_PROVIDER_NAME = {
   anthropic: "Claude",
   openai: "ChatGPT",
   cursor: "Cursor",
-  xai: "Grok"
+  xai: "Grok",
+  meta: "Muse"
 };
 var MODEL_SUBSCRIPTION_PLAN_PHRASE = {
   anthropic: "Claude subscription",
   openai: "ChatGPT plan",
   cursor: "Cursor plan",
-  xai: "Grok subscription"
+  xai: "Grok subscription",
+  meta: "Muse subscription"
 };
 var AGENT_TYPE_META = {
   ...Object.fromEntries(ACP_AGENT_TYPES.map((agentType) => [agentType, {
@@ -22362,8 +22405,10 @@ var spendCapPolicyConfigSchema = external_exports.object({
 });
 var callCountPolicyConfigSchema = external_exports.object({ limitPerSession: external_exports.number().int().min(1).max(1e5) }).strict();
 var capabilityPolicyConfigSchema = external_exports.record(external_exports.string(), external_exports.enum(POLICY_ACTIONS)).superRefine((obj, ctx) => {
-  for (const k of Object.keys(obj)) {
-    if (!CAPABILITY_IDS.includes(k)) {
+  for (const [k, action] of Object.entries(obj)) {
+    if (PLATFORM_CAPABILITY_IDS.includes(k)) {
+      if (action === "ask") ctx.addIssue({ code: "custom", message: `${k} accepts allow or deny`, path: [k] });
+    } else if (!CAPABILITY_IDS.includes(k)) {
       ctx.addIssue({ code: "custom", message: `unknown capability id: ${k}`, path: [k] });
     }
   }

package/dist/index.js

@@ -16,10 +16,10 @@ import {
   skillRefSchema,
   splitMcpServers,
   supersededBy
-} from "./chunk-IC4N2ZPL.js";
+} from "./chunk-WFTZR5YO.js";
 
 // src/index.ts
-import { existsSync as existsSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename3, resolve as resolve4 } from "path";
 import { createInterface as createInterface4 } from "readline";
 import { Command } from "commander";
@@ -64,7 +64,7 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.7.3";
+var CLI_VERSION = "2.8.0";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 // src/api.ts
@@ -148,6 +148,24 @@ async function downloadFile(fileId) {
   if (!res.ok) await parseError(res);
   return { bytes: new Uint8Array(await res.arrayBuffer()), mediaType: res.headers.get("content-type") ?? "application/octet-stream" };
 }
+async function apiBytes(method, path, body) {
+  const res = await fetch(`${apiBase()}${path}`, {
+    method,
+    headers: {
+      "user-agent": USER_AGENT,
+      ...authHeaders(),
+      ...body ? { "content-type": body.mediaType } : {}
+    },
+    body: body ? new Uint8Array(body.bytes) : void 0
+  });
+  if (!res.ok) await parseError(res);
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  return {
+    bytes,
+    mediaType: res.headers.get("content-type") ?? "application/octet-stream",
+    json: () => JSON.parse(new TextDecoder().decode(bytes))
+  };
+}
 async function resolveSessionRef(ref) {
   if (ref.startsWith("sess-")) return ref;
   const { agent: agent2 } = await api(
@@ -167,7 +185,7 @@ async function resolveSessionRef(ref) {
   return agent2.defaultSessionId;
 }
 async function* streamEvents(sessionId, signal) {
-  const { parseSseStream } = await import("./src-S76Y7GHZ.js");
+  const { parseSseStream } = await import("./src-2DLGPJB6.js");
   const res = await fetch(
     `${apiBase()}/sessions/${encodeURIComponent(sessionId)}/stream`,
     {
@@ -1977,6 +1995,144 @@ async function importToWorkspace(key, held, skills, instructions, emit) {
   if (!finished.ok) emit({ type: "error", code: finished.code, message: finished.message });
 }
 
+// src/task-files.ts
+function encodePath(path) {
+  return path.replace(/^\/+/, "").split("/").map(encodeURIComponent).join("/");
+}
+var filesPath = (task2) => `/tasks/${encodeURIComponent(task2)}/files`;
+async function listTaskFiles(task2) {
+  return (await api("GET", filesPath(task2))).files;
+}
+async function readTaskFile(task2, path) {
+  return (await apiBytes("GET", `${filesPath(task2)}/${encodePath(path)}`)).bytes;
+}
+async function writeTaskFile(task2, path, bytes, mediaType) {
+  return (await apiBytes("PUT", `${filesPath(task2)}/${encodePath(path)}`, { bytes, mediaType })).json();
+}
+async function deleteTaskFile(task2, path) {
+  await api("DELETE", `${filesPath(task2)}/${encodePath(path)}`);
+}
+async function listArtifacts(task2) {
+  const query = task2 ? `?task_id=${encodeURIComponent(task2)}` : "";
+  return (await api("GET", `/artifacts${query}`)).artifacts;
+}
+function publishBody(task2, options) {
+  return { task_id: task2, name: options.name, paths: options.path, ...options.entry ? { entry: options.entry } : {} };
+}
+async function publishArtifact(task2, options) {
+  return (await api("POST", "/artifacts", publishBody(task2, options))).artifact;
+}
+async function readArtifactFile(id, path) {
+  return (await apiBytes("GET", `/artifacts/${encodeURIComponent(id)}/files/${encodePath(path)}`)).bytes;
+}
+async function shareArtifact(id, enabled) {
+  return (await api("POST", `/artifacts/${encodeURIComponent(id)}/share`, { enabled })).share_url;
+}
+async function deleteArtifact(id) {
+  await api("DELETE", `/artifacts/${encodeURIComponent(id)}`);
+}
+function renderTaskFile(file) {
+  return `${file.path}  ${file.size_bytes} bytes  ${file.updated_at}${file.updated_by_session ? `  by ${file.updated_by_session}` : ""}`;
+}
+function renderArtifact(artifact2) {
+  const files2 = `${artifact2.files.length} ${artifact2.files.length === 1 ? "file" : "files"}`;
+  return `${artifact2.id}  ${artifact2.name}  v${artifact2.version}  ${files2}  entry ${artifact2.entry}${artifact2.share_url ? `  shared ${artifact2.share_url}` : ""}`;
+}
+
+// src/workspace.ts
+var KINDS = ["TOOL_CALL", "SPEND_CAP", "CALL_COUNT", "CAPABILITY"];
+async function workspaceSlug(explicit) {
+  if (explicit) return explicit;
+  const current = currentUniverse();
+  if (current) return current;
+  return (await api("GET", "/whoami")).universe.slug;
+}
+var workspacePath = (slug) => `/universes/${encodeURIComponent(slug)}`;
+async function listMembers(slug) {
+  return api("GET", `${workspacePath(slug)}/members`);
+}
+function findMember(members, ref) {
+  const needle = ref.toLowerCase();
+  const found = members.find((m) => m.user_id === ref || m.email?.toLowerCase() === needle);
+  if (!found) throw new ApiError(404, "not_found", `no member ${ref} in this workspace`);
+  return found;
+}
+function inviteBody(emails, options) {
+  if (options.role && options.role !== "admin" && options.role !== "member") {
+    throw new ApiError(400, "invalid_request", "--role is admin or member");
+  }
+  return {
+    emails,
+    ...options.role ? { role: options.role } : {},
+    ...options.sendEmail ? { send_email: true } : {}
+  };
+}
+async function invite(slug, emails, options) {
+  return api("POST", `${workspacePath(slug)}/invites`, inviteBody(emails, options));
+}
+async function withdrawInvite(slug, inviteId) {
+  await api("DELETE", `${workspacePath(slug)}/invites/${encodeURIComponent(inviteId)}`);
+}
+async function setRole(slug, memberRef, role) {
+  if (role !== "admin" && role !== "member") throw new ApiError(400, "invalid_request", "a role is admin or member");
+  const member = findMember((await listMembers(slug)).members, memberRef);
+  await api("PATCH", `${workspacePath(slug)}/members/${encodeURIComponent(member.user_id)}`, { role });
+  return member;
+}
+async function removeMember(slug, memberRef) {
+  const member = findMember((await listMembers(slug)).members, memberRef);
+  await api("DELETE", `${workspacePath(slug)}/members/${encodeURIComponent(member.user_id)}`);
+  return member;
+}
+async function joinWorkspace(token) {
+  return (await api("POST", `/invites/${encodeURIComponent(token)}`)).workspace;
+}
+function renderMembers(page) {
+  const lines = page.members.map((m) => `${m.role.padEnd(6)}  ${m.email ?? m.user_id}${m.name ? `  (${m.name})` : ""}  ${m.user_id}`);
+  for (const i of page.invites) lines.push(`invited ${i.email} as ${i.role} by ${i.invited_by} until ${i.expires_at.slice(0, 10)}  ${i.id}`);
+  return lines;
+}
+function policyRuleBody(options) {
+  const kind = options.kind.toUpperCase().replace(/-/g, "_");
+  if (!KINDS.includes(kind)) throw new ApiError(400, "invalid_request", `--kind is one of ${KINDS.join(", ")}`);
+  let config;
+  try {
+    config = JSON.parse(options.config);
+  } catch {
+    throw new ApiError(400, "invalid_request", "--config must be a JSON object");
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new ApiError(400, "invalid_request", "--config must be a JSON object");
+  }
+  const position = options.position === void 0 ? void 0 : Number(options.position);
+  if (position !== void 0 && !Number.isInteger(position)) throw new ApiError(400, "invalid_request", "--position is a whole number");
+  return {
+    name: options.name,
+    kind,
+    config,
+    ...position !== void 0 ? { position } : {},
+    ...options.disabled ? { enabled: false } : {}
+  };
+}
+var policiesPath = (scope) => "session" in scope ? `/sessions/${encodeURIComponent(scope.session)}/policies` : `${workspacePath(scope.slug)}/policies`;
+async function listPolicies(scope, effective = false) {
+  if (effective && "session" in scope) return api("GET", `/sessions/${encodeURIComponent(scope.session)}/effective-policy`);
+  return api("GET", policiesPath(scope));
+}
+async function addPolicy(scope, options) {
+  return (await api("POST", policiesPath(scope), policyRuleBody(options))).rule;
+}
+async function setPolicyEnabled(scope, ruleId, enabled) {
+  return (await api("PATCH", `${policiesPath(scope)}/${encodeURIComponent(ruleId)}`, { enabled })).rule;
+}
+async function removePolicy(scope, ruleId) {
+  await api("DELETE", `${policiesPath(scope)}/${encodeURIComponent(ruleId)}`);
+}
+function renderPolicy(rule) {
+  const state = rule.enabled ? "on " : "off";
+  return `${state}  ${rule.layer.padEnd(9)}  ${rule.kind.padEnd(10)}  ${rule.name}  ${JSON.stringify(rule.config)}  ${rule.id}`;
+}
+
 // src/index.ts
 function printModelBilling(session2) {
   if (session2.modelBilling !== "account") return;
@@ -2055,6 +2211,84 @@ universe.command("show").action(
     }
   })
 );
+universe.command("members [slug]").description("who is in the workspace, and who is invited (owners and admins)").action(
+  run(async (slug) => {
+    for (const line of renderMembers(await listMembers(await workspaceSlug(slug)))) console.log(line);
+  })
+);
+universe.command("invite <emails...>").description("invite people by email; prints each person's join link token").option("--role <role>", "admin | member (default member; admin needs the owner)").option("--send-email", "also email each invitation").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (emails, opts) => {
+    const result = await invite(await workspaceSlug(opts.universe), emails, opts);
+    for (const i of result.invites) console.log(`invited ${i.email} as ${i.role}  ${i.id}`);
+    for (const link of result.links) console.log(`  ${link.email} joins with: sky universe join ${link.token}`);
+    if (!result.invites.length) console.log("nobody new to invite \u2014 everyone listed is already a member");
+  })
+);
+universe.command("uninvite <inviteId>").description("withdraw an invitation that has not been taken up").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (inviteId, opts) => {
+    await withdrawInvite(await workspaceSlug(opts.universe), inviteId);
+    console.log(`Withdrew ${inviteId}`);
+  })
+);
+universe.command("role <member> <role>").description("make a member (user id or email) an admin or a member (owner only)").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (memberRef, role, opts) => {
+    const member = await setRole(await workspaceSlug(opts.universe), memberRef, role);
+    console.log(`${member.email ?? member.user_id} is now ${role}`);
+  })
+);
+universe.command("remove <member>").description("remove a member (user id or email) from the workspace (owner only)").option("--universe <slug>", "the workspace (default: the current one)").action(
+  run(async (memberRef, opts) => {
+    const member = await removeMember(await workspaceSlug(opts.universe), memberRef);
+    console.log(`Removed ${member.email ?? member.user_id}`);
+  })
+);
+universe.command("join <token>").description("accept an invitation sent to your verified email").action(
+  run(async (token) => {
+    const workspace = await joinWorkspace(token);
+    console.log(`Joined ${workspace.slug} (${workspace.name}) \u2014 sky universe switch ${workspace.slug}`);
+  })
+);
+var policy = program.command("policy").description("policy rules: tool calls, spend caps, call counts, capabilities");
+async function policyScope(opts) {
+  return opts.session ? { session: await resolveSessionRef(opts.session) } : { slug: await workspaceSlug(opts.universe) };
+}
+var scopeOptions = (command) => command.option("--session <ref>", "one session's rules instead of the workspace's").option("--universe <slug>", "the workspace (default: the current one)");
+scopeOptions(
+  policy.command("list").description("the workspace's rules, or one session's; --effective merges every layer").option("--effective", "with --session: every rule the session runs under")
+).action(
+  run(async (opts) => {
+    const { rules, note } = await listPolicies(await policyScope(opts), opts.effective);
+    if (!rules.length) console.log("no policy rules");
+    for (const rule of rules) console.log(renderPolicy(rule));
+    if (note) console.log(note);
+  })
+);
+scopeOptions(
+  policy.command("add").description("add a rule (workspace owner, or the session's owner with --session)").requiredOption("--name <name>", "what the rule is for").requiredOption("--kind <kind>", "TOOL_CALL | SPEND_CAP | CALL_COUNT | CAPABILITY").requiredOption(
+    "--config <json>",
+    `e.g. '{"action":"deny","matcher":"Bash","commandPatterns":["rm -rf *"]}', '{"hardCapUsdMicros":5000000}', '{"limitPerSession":200}', '{"platform.orchestration":"deny"}'`
+  ).option("--position <n>", "evaluation order, lowest first (default 0)").option("--disabled", "create it switched off")
+).action(
+  run(async (opts) => {
+    console.log(renderPolicy(await addPolicy(await policyScope(opts), opts)));
+  })
+);
+for (const [verb, enabled, description] of [
+  ["enable", true, "switch a rule on"],
+  ["disable", false, "switch a rule off (kept, so it can be switched on again)"]
+]) {
+  scopeOptions(policy.command(`${verb} <ruleId>`).description(description)).action(
+    run(async (ruleId, opts) => {
+      console.log(renderPolicy(await setPolicyEnabled(await policyScope(opts), ruleId, enabled)));
+    })
+  );
+}
+scopeOptions(policy.command("rm <ruleId>").description("delete a rule")).action(
+  run(async (ruleId, opts) => {
+    await removePolicy(await policyScope(opts), ruleId);
+    console.log(`Deleted ${ruleId}`);
+  })
+);
 var agent = program.command("agent").description("agent specs: create, inspect, talk (via the default session)");
 agent.command("create").description("create an agent spec \u2014 no runtime; `sky session create` starts one").option("--type <type>", "hermes | claude_code | codex | openclaw | pi | dsh | kimi_code | opencode").option("--llm <llm>", "model id (defaults per type)").option(
   "--reasoning-effort <level>",
@@ -2700,6 +2934,69 @@ files.command("download <id>").description("download a session file's bytes").re
     console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
   })
 );
+var task = program.command("task").description("a task's shared files (the task is its first session's id)");
+task.command("files <task>").description("list the task's current files").action(
+  run(async (taskId) => {
+    const list = await listTaskFiles(taskId);
+    if (!list.length) console.log("no files");
+    for (const file of list) console.log(renderTaskFile(file));
+  })
+);
+task.command("get <task> <path>").description("read one task file; prints it, or writes it with -o").option("-o, --out <path>", "where to write the bytes").action(
+  run(async (taskId, path, opts) => {
+    const bytes = await readTaskFile(taskId, path);
+    if (opts.out) {
+      writeFileSync6(opts.out, bytes);
+      console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
+    } else process.stdout.write(bytes);
+  })
+);
+task.command("put <task> <path> <local>").description("write a local file to <path> in the task's files (every session of the task sees it)").action(
+  run(async (taskId, path, local) => {
+    const { file, conflict } = await writeTaskFile(taskId, path, readFileSync10(local), mediaTypeFor(local));
+    console.log(`${renderTaskFile(file)}${conflict ? "  (replaced a version you had not seen)" : ""}`);
+  })
+);
+task.command("rm <task> <path>").description("remove a path from the task's files (its history is kept)").action(
+  run(async (taskId, path) => {
+    await deleteTaskFile(taskId, path);
+    console.log(`Removed ${path}`);
+  })
+);
+var artifact = program.command("artifact").description("artifacts: publish a task's files as a named, shareable result");
+artifact.command("list").description("the workspace's artifacts, or one task's with --task").option("--task <task>", "only this task's artifacts").action(
+  run(async (opts) => {
+    const list = await listArtifacts(opts.task);
+    if (!list.length) console.log("no artifacts");
+    for (const a of list) console.log(renderArtifact(a));
+  })
+);
+artifact.command("publish <task>").description("publish paths from the task's files as a new version of the named artifact").requiredOption("--name <name>", "the artifact's name; publishing the same name again adds a version").requiredOption("--path <path...>", "task file paths to include").option("--entry <path>", "the file a viewer opens first (default: the first path)").action(
+  run(async (taskId, opts) => {
+    console.log(renderArtifact(await publishArtifact(taskId, opts)));
+  })
+);
+artifact.command("get <id> <path>").description("read one file of an artifact; prints it, or writes it with -o").option("-o, --out <path>", "where to write the bytes").action(
+  run(async (id, path, opts) => {
+    const bytes = await readArtifactFile(id, path);
+    if (opts.out) {
+      writeFileSync6(opts.out, bytes);
+      console.log(`Wrote ${bytes.length} bytes to ${opts.out}`);
+    } else process.stdout.write(bytes);
+  })
+);
+artifact.command("share <id>").description("turn on a public link anyone can open; --off turns it off (the old link stops working)").option("--off", "stop sharing").action(
+  run(async (id, opts) => {
+    const url = await shareArtifact(id, !opts.off);
+    console.log(url ?? `Stopped sharing ${id}`);
+  })
+);
+artifact.command("rm <id>").description("delete an artifact").action(
+  run(async (id) => {
+    await deleteArtifact(id);
+    console.log(`Deleted ${id}`);
+  })
+);
 function routineLine(r) {
   const target = r.target.type === "session" ? `\u2192 ${r.target.session_id}` : `+ ${r.target.agent}`;
   const cron = r.schedule ? `${r.schedule.expression} ${r.schedule.timezone}` : "manual-only";

package/dist/products.js

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

package/dist/{src-S76Y7GHZ.js → src-2DLGPJB6.js}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsky/sky",
-  "version": "2.7.3",
+  "version": "2.8.0",
   "description": "sky — the AgentSky developer CLI: launch and talk to long-lived agents from your terminal.",
   "license": "MIT",
   "type": "module",