@nema-project/nema 0.1.4 → 0.1.6

package/dist/chunks/{chunk-HEIQINX3.js → chunk-W4DUBATU.js}

@@ -32,12 +32,49 @@ var Implementation = z.object({
 });
 
 // ../../../packages/shared/dist/entry.js
+import { z as z3 } from "zod";
+
+// ../../../packages/shared/dist/sourceEvidence.js
 import { z as z2 } from "zod";
+var NoControls = /^[^\x00-\x1f\x7f]*$/;
+var SourceRevision = z2.string().min(1).max(256).regex(NoControls).nullable();
+var SnapshotHash = z2.string().regex(/^[0-9a-f]{64}$/);
+var SourceExcerpt = z2.object({
+  locator: z2.string().min(1).max(200),
+  text: z2.string().min(1).max(2e3)
+});
+var SourceSnapshot = z2.object({
+  schemaVersion: z2.literal(1),
+  provider: z2.string().regex(/^[a-z][a-z0-9_-]{0,63}$/),
+  resourceId: z2.string().min(1).max(512).regex(NoControls).refine((value) => value.trim() === value, "resourceId must not have surrounding whitespace"),
+  revision: SourceRevision,
+  fetchedAt: z2.iso.datetime({ offset: true }),
+  title: z2.string().min(1).max(200),
+  canonicalUrl: z2.string().refine((value) => {
+    try {
+      const url = new URL(value);
+      return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "";
+    } catch {
+      return false;
+    }
+  }, "canonicalUrl must be http or https without user information").nullable(),
+  contentHash: SnapshotHash,
+  excerpts: z2.array(SourceExcerpt).min(1).max(20).refine((excerpts) => excerpts.reduce((total, excerpt) => total + excerpt.text.length, 0) <= 8e3, "excerpt text must total at most 8000 characters")
+});
+var SourceRef = z2.object({
+  sourceEntryId: z2.string().regex(/^S-[1-9]\d*$/),
+  revision: SourceRevision,
+  snapshotHash: SnapshotHash,
+  locator: z2.string().min(1).max(200).optional(),
+  quote: z2.string().min(1).max(500).optional()
+}).refine((ref) => ref.quote === void 0 || ref.locator !== void 0, { path: ["locator"], message: "locator is required with quote" });
+
+// ../../../packages/shared/dist/entry.js
 var ENTRY_KINDS = ["requirement", "decision", "tradeoff", "question", "source", "diagram", "workpackage"];
-var EntryKindSchema = z2.enum(ENTRY_KINDS);
+var EntryKindSchema = z3.enum(ENTRY_KINDS);
 var BASIS_VALUES = ["stated", "decided", "inferred"];
-var BasisSchema = z2.enum(BASIS_VALUES);
-var Quote = z2.object({ messageId: z2.string().min(1), text: z2.string().min(1).max(500) });
+var BasisSchema = z3.enum(BASIS_VALUES);
+var Quote = z3.object({ messageId: z3.string().min(1), text: z3.string().min(1).max(500) });
 var DIAGRAM_TYPES = [
   "architecture",
   "workflow",
@@ -50,34 +87,34 @@ var DIAGRAM_TYPES = [
   "timeline",
   "waterfall"
 ];
-var DiagramMeta = z2.object({
-  repoId: z2.string().min(1),
-  type: z2.enum(DIAGRAM_TYPES),
+var DiagramMeta = z3.object({
+  repoId: z3.string().min(1),
+  type: z3.enum(DIAGRAM_TYPES),
   /** repo id -> main sha the diagram was drawn at. */
-  sourceCommits: z2.record(z2.string(), z2.string()),
+  sourceCommits: z3.record(z3.string(), z3.string()),
   /** archify node id -> repo-relative paths that node stands for. */
-  nodePaths: z2.record(z2.string(), z2.array(z2.string()))
+  nodePaths: z3.record(z3.string(), z3.array(z3.string()))
 });
 var MAX_WP_TASKS = 15;
-var WpTask = z2.object({
-  n: z2.number().int().min(1).max(MAX_WP_TASKS),
-  title: z2.string(),
-  satisfies: z2.array(z2.string()),
-  files: z2.array(z2.object({ op: z2.enum(["modify", "create"]), repo: z2.string(), path: z2.string() })),
-  status: z2.enum(["pending", "reported", "verified", "mismatch"]),
-  inferred: z2.boolean(),
-  reportMessageId: z2.string().nullable(),
-  confirmedBy: z2.literal("user").nullable()
+var WpTask = z3.object({
+  n: z3.number().int().min(1).max(MAX_WP_TASKS),
+  title: z3.string(),
+  satisfies: z3.array(z3.string()),
+  files: z3.array(z3.object({ op: z3.enum(["modify", "create"]), repo: z3.string(), path: z3.string() })),
+  status: z3.enum(["pending", "reported", "verified", "mismatch"]),
+  inferred: z3.boolean(),
+  reportMessageId: z3.string().nullable(),
+  confirmedBy: z3.literal("user").nullable()
 });
-var WorkPackageMeta = z2.object({
-  requirements: z2.array(z2.string()),
-  repos: z2.array(z2.string()),
-  approvedAt: z2.string().nullable(),
-  approvedCommit: z2.string().nullable(),
-  blockedOn: z2.string().nullable(),
-  tasks: z2.array(WpTask)
+var WorkPackageMeta = z3.object({
+  requirements: z3.array(z3.string()),
+  repos: z3.array(z3.string()),
+  approvedAt: z3.string().nullable(),
+  approvedCommit: z3.string().nullable(),
+  blockedOn: z3.string().nullable(),
+  tasks: z3.array(WpTask)
 });
-var IsoDateTime = z2.iso.datetime({ offset: true }).nullable();
+var IsoDateTime = z3.iso.datetime({ offset: true }).nullable();
 var PREFIX_KIND = {
   R: "requirement",
   D: "decision",
@@ -103,9 +140,9 @@ var KIND_STATUSES = {
   workpackage: ["draft", "approved", "in_progress", "done", "dropped"]
 };
 var ALL_STATUSES = ["active", "superseded", "dropped", "open", "resolved", "draft", "approved", "in_progress", "done"];
-var StatusSchema = z2.enum(ALL_STATUSES);
-var BusinessDate = z2.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable();
-var HttpUrl = z2.string().refine((s) => {
+var StatusSchema = z3.enum(ALL_STATUSES);
+var BusinessDate = z3.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable();
+var HttpUrl = z3.string().refine((s) => {
   try {
     const p = new URL(s).protocol;
     return p === "http:" || p === "https:";
@@ -113,17 +150,23 @@ var HttpUrl = z2.string().refine((s) => {
     return false;
   }
 }, "url must be http or https");
-var Priority = z2.union([z2.literal(1), z2.literal(2), z2.literal(3)]);
+var Priority = z3.union([z3.literal(1), z3.literal(2), z3.literal(3)]);
 function refineKind(v, ctx) {
   if (v.status !== void 0 && !KIND_STATUSES[v.kind].includes(v.status)) {
     ctx.addIssue({ code: "custom", path: ["status"], message: `invalid status "${v.status}" for ${v.kind}` });
   }
   if (v.kind === "source") {
-    if (v.url === void 0)
+    if (v.url === void 0 && v.sourceSnapshot === void 0)
       ctx.addIssue({ code: "custom", path: ["url"], message: "url is required for source" });
   } else if (v.url !== void 0) {
     ctx.addIssue({ code: "custom", path: ["url"], message: "url is only allowed for source" });
   }
+  if (v.sourceSnapshot !== void 0 && v.kind !== "source") {
+    ctx.addIssue({ code: "custom", path: ["sourceSnapshot"], message: "sourceSnapshot is only allowed for source" });
+  }
+  if (v.confirmedRevision != null && (v.kind !== "source" || v.sourceSnapshot === void 0)) {
+    ctx.addIssue({ code: "custom", path: ["confirmedRevision"], message: "confirmedRevision requires a source snapshot" });
+  }
   if (v.kind === "diagram") {
     if (v.diagram === void 0)
       ctx.addIssue({ code: "custom", path: ["diagram"], message: "diagram is required for diagram" });
@@ -146,14 +189,17 @@ function refineKind(v, ctx) {
     ctx.addIssue({ code: "custom", path: ["priority"], message: "priority is only allowed for question" });
   }
 }
-var EntryFrontmatter = z2.object({
-  id: z2.string().regex(ID_RE),
+var EntryFrontmatter = z3.object({
+  id: z3.string().regex(ID_RE),
   kind: EntryKindSchema,
-  title: z2.string().min(1).max(200),
+  title: z3.string().min(1).max(200),
   status: StatusSchema,
   businessDate: BusinessDate,
-  related: z2.array(z2.string()),
-  sourceMessages: z2.array(z2.string()),
+  related: z3.array(z3.string()),
+  sourceMessages: z3.array(z3.string()),
+  sourceSnapshot: SourceSnapshot.optional(),
+  sourceRefs: z3.array(SourceRef).max(10).default([]),
+  confirmedRevision: SourceRevision.default(null),
   url: HttpUrl.optional(),
   priority: Priority.optional(),
   diagram: DiagramMeta.optional(),
@@ -162,30 +208,31 @@ var EntryFrontmatter = z2.object({
   basis: BasisSchema.nullable(),
   ingestedAt: IsoDateTime,
   confirmedAt: IsoDateTime,
-  quotes: z2.array(Quote)
+  quotes: z3.array(Quote)
 }).superRefine((v, ctx) => {
   refineKind(v, ctx);
   if (kindFromId(v.id) !== v.kind) {
     ctx.addIssue({ code: "custom", path: ["id"], message: "id prefix does not match kind" });
   }
 });
-var UpsertEntryInput = z2.object({
-  id: z2.string().regex(ID_RE).optional(),
+var UpsertEntryInput = z3.object({
+  id: z3.string().regex(ID_RE).optional(),
   kind: EntryKindSchema,
-  title: z2.string().min(1).max(200),
-  body: z2.string(),
+  title: z3.string().min(1).max(200),
+  body: z3.string(),
   status: StatusSchema.optional(),
   businessDate: BusinessDate.optional(),
-  related: z2.array(z2.string()).optional(),
-  sourceMessages: z2.array(z2.string()).default([]),
+  related: z3.array(z3.string()).optional(),
+  sourceMessages: z3.array(z3.string()).default([]),
+  sourceRefs: z3.array(SourceRef).max(10).optional(),
   url: HttpUrl.optional(),
   priority: Priority.optional(),
   /** Requirements only. The Room API checks it against reports; omitted keeps the stored one. */
   implementation: Implementation.optional(),
   basis: BasisSchema.optional(),
-  quotes: z2.array(Quote).max(10).optional(),
-  confirmed: z2.boolean().optional(),
-  reason: z2.string().min(1).max(500)
+  quotes: z3.array(Quote).max(10).optional(),
+  confirmed: z3.boolean().optional(),
+  reason: z3.string().min(1).max(500)
 }).superRefine((v, ctx) => {
   refineKind(v, ctx);
   if (v.id !== void 0 && kindFromId(v.id) !== v.kind) {
@@ -194,23 +241,23 @@ var UpsertEntryInput = z2.object({
 });
 
 // ../../../packages/shared/dist/workspace.js
-import { z as z3 } from "zod";
-var MessageQuote = z3.object({
-  messageId: z3.string(),
-  role: z3.enum(["user", "agent", "system", "report"]),
-  excerpt: z3.string()
+import { z as z4 } from "zod";
+var MessageQuote = z4.object({
+  messageId: z4.string(),
+  role: z4.enum(["user", "agent", "system", "report"]),
+  excerpt: z4.string()
 });
-var UserMessageMeta = z3.object({
+var UserMessageMeta = z4.object({
   quote: MessageQuote.optional()
 });
-var AgentMessageMeta = z3.object({
-  changes: z3.array(z3.object({
-    entryId: z3.string(),
+var AgentMessageMeta = z4.object({
+  changes: z4.array(z4.object({
+    entryId: z4.string(),
     kind: EntryKindSchema,
-    title: z3.string(),
-    op: z3.enum(["add", "update"])
+    title: z4.string(),
+    op: z4.enum(["add", "update"])
   })),
-  askedQuestion: z3.object({ id: z3.string(), title: z3.string(), body: z3.string() }).nullable(),
+  askedQuestion: z4.object({ id: z4.string(), title: z4.string(), body: z4.string() }).nullable(),
   quote: MessageQuote.optional()
 });
 function isBranchName(name) {
@@ -626,49 +673,140 @@ function bundledExtensions() {
   ];
 }
 
+// ../../../packages/shared/dist/extensionSource.js
+var MAX_INPUT = 2048;
+var OWNER2 = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/;
+var REPO = /^[A-Za-z0-9._-]{1,100}$/;
+var SEGMENT = /^[A-Za-z0-9._-]{1,255}$/;
+var REF = /^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$/;
+function refuse(input) {
+  throw new Error(`unsupported extension source: ${input.length > 200 ? `${input.slice(0, 200)}\u2026` : input}`);
+}
+function plainSegment(segment) {
+  return SEGMENT.test(segment) && segment !== "." && segment !== "..";
+}
+function repoName(segment) {
+  const name = segment.endsWith(".git") ? segment.slice(0, -4) : segment;
+  return REPO.test(name) && name !== "." && name !== ".." ? name : null;
+}
+function parseSkillSource(raw) {
+  const input = raw.trim();
+  if (!input || input.length > MAX_INPUT)
+    refuse(input);
+  if (!input.includes(":") && !input.startsWith("github.com/") && /^[^/]+\/[^/]+$/.test(input)) {
+    const [owner2, repo2] = input.split("/");
+    const name = repoName(repo2);
+    if (!OWNER2.test(owner2) || !name)
+      refuse(input);
+    return { via: "github", owner: owner2, repo: name, ref: null, path: null, skill: null, refPath: null, exact: false };
+  }
+  let url;
+  try {
+    url = new URL(input.startsWith("github.com/") ? `https://${input}` : input);
+  } catch {
+    refuse(input);
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.port || url.search || url.hash)
+    refuse(input);
+  const typedPath = input.replace(/^https:\/\/[^/]+/, "").replace(/^github\.com/, "");
+  if (typedPath !== url.pathname)
+    refuse(input);
+  const segments = url.pathname.replace(/\/$/, "").split("/").slice(1);
+  if (segments.some((part) => part === ""))
+    refuse(input);
+  const host = url.hostname.toLowerCase();
+  if (host === "skills.sh" || host === "www.skills.sh") {
+    if (segments.length < 2 || segments.length > 3 || !segments.every(plainSegment))
+      refuse(input);
+    const name = repoName(segments[1]);
+    if (!OWNER2.test(segments[0]) || !name)
+      refuse(input);
+    return { via: "skills.sh", owner: segments[0], repo: name, ref: null, path: null, skill: segments[2] ?? null, refPath: null, exact: false };
+  }
+  if (host !== "github.com" && host !== "www.github.com")
+    refuse(input);
+  if (segments.length < 2)
+    refuse(input);
+  const [owner, repoSegment, kind, ref, ...rest] = segments;
+  const repo = repoName(repoSegment);
+  if (!OWNER2.test(owner) || !repo)
+    refuse(input);
+  if (kind === void 0)
+    return { via: "github", owner, repo, ref: null, path: null, skill: null, refPath: null, exact: false };
+  if (kind !== "tree" && kind !== "blob" || ref === void 0 || !REF.test(ref) || ref.includes(".."))
+    refuse(input);
+  if (!rest.every(plainSegment))
+    refuse(input);
+  let folder = rest;
+  if (kind === "blob") {
+    if (rest.at(-1) !== "SKILL.md")
+      refuse(input);
+    folder = rest.slice(0, -1);
+  }
+  return {
+    via: "github",
+    owner,
+    repo,
+    ref,
+    path: folder.length ? folder.join("/") : null,
+    skill: null,
+    refPath: [ref, ...folder].join("/"),
+    exact: kind === "blob"
+  };
+}
+var UNSAFE_NAME = /[\\/:*?"<>|\u0000-\u001f]/;
+var WINDOWS_DEVICE = /^(con|prn|aux|nul|com[0-9¹²³]|lpt[0-9¹²³])(\..*)?$/i;
+function safeFileName(name) {
+  return name !== "" && name !== "." && name !== ".." && name.length <= 255 && !UNSAFE_NAME.test(name) && !WINDOWS_DEVICE.test(name) && // Windows drops a trailing dot or space, so `a.` and `a` would be the same file there.
+  !/[. ]$/.test(name);
+}
+function safeRepoPath(relative) {
+  return relative.split("/").every(safeFileName);
+}
+
 // ../../../packages/shared/dist/protocol.js
-import { z as z4 } from "zod";
-var DaemonToHubSchema = z4.union([
-  z4.object({
-    type: z4.literal("hello"),
-    token: z4.string(),
-    version: z4.string(),
-    adapters: z4.array(z4.string()),
+import { z as z5 } from "zod";
+var DaemonToHubSchema = z5.union([
+  z5.object({
+    type: z5.literal("hello"),
+    token: z5.string(),
+    version: z5.string(),
+    adapters: z5.array(z5.string()),
     /** sha256 hex of ~/.nema/report-token, sent when that file exists. */
-    reportTokenHash: z4.string().regex(/^[0-9a-f]{64}$/).optional()
+    reportTokenHash: z5.string().regex(/^[0-9a-f]{64}$/).optional()
   }),
-  z4.object({
-    type: z4.literal("task.event"),
-    taskId: z4.string(),
-    event: z4.object({ type: z4.enum(["progress", "agent_message", "tool_call"]), text: z4.string() })
+  z5.object({
+    type: z5.literal("task.event"),
+    taskId: z5.string(),
+    event: z5.object({ type: z5.enum(["progress", "agent_message", "tool_call"]), text: z5.string() })
   }),
-  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(true), reply: z4.string() }),
-  z4.object({ type: z4.literal("task.finished"), taskId: z4.string(), ok: z4.literal(false), error: z4.string() }),
-  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(true), result: z4.unknown() }),
-  z4.object({ type: z4.literal("rpc.response"), id: z4.string(), ok: z4.literal(false), error: z4.string() }),
-  z4.object({ type: z4.literal("repo.moved"), repoId: z4.string(), mainRef: z4.string(), from: z4.string().nullable(), to: z4.string() }),
-  z4.object({ type: z4.literal("repo.fetched"), repoId: z4.string(), ok: z4.boolean(), error: z4.string().optional(), at: z4.string() })
+  z5.object({ type: z5.literal("task.finished"), taskId: z5.string(), ok: z5.literal(true), reply: z5.string() }),
+  z5.object({ type: z5.literal("task.finished"), taskId: z5.string(), ok: z5.literal(false), error: z5.string() }),
+  z5.object({ type: z5.literal("rpc.response"), id: z5.string(), ok: z5.literal(true), result: z5.unknown() }),
+  z5.object({ type: z5.literal("rpc.response"), id: z5.string(), ok: z5.literal(false), error: z5.string() }),
+  z5.object({ type: z5.literal("repo.moved"), repoId: z5.string(), mainRef: z5.string(), from: z5.string().nullable(), to: z5.string() }),
+  z5.object({ type: z5.literal("repo.fetched"), repoId: z5.string(), ok: z5.boolean(), error: z5.string().optional(), at: z5.string() })
 ]);
-var HubToDaemonSchema = z4.discriminatedUnion("type", [
+var HubToDaemonSchema = z5.discriminatedUnion("type", [
   // workspaceIds: every workspace that still exists, so the daemon can remove the isolation dirs
   // (`~/.nema/ws/<id>`) of workspaces deleted while it was offline. Optional for older hubs.
-  z4.object({ type: z4.literal("welcome"), workspaceIds: z4.array(z4.string()).optional() }),
+  z5.object({ type: z5.literal("welcome"), workspaceIds: z5.array(z5.string()).optional() }),
   // Sent to a connected daemon when a workspace is deleted, so it removes that workspace's isolation dir.
-  z4.object({ type: z4.literal("workspace.deleted"), workspaceId: z4.string() }),
-  z4.object({
-    type: z4.literal("task.assign"),
-    taskId: z4.string(),
-    workspaceId: z4.string(),
-    adapter: z4.string().min(1),
-    confidential: z4.boolean(),
-    prompt: z4.string(),
-    runToken: z4.string(),
-    hubUrl: z4.string(),
-    pluginTools: z4.array(z4.object({ name: z4.string(), description: z4.string(), parameters: z4.record(z4.string(), z4.unknown()) })),
-    limits: z4.object({ maxModelCalls: z4.number().int().min(1), maxToolCalls: z4.number().int().min(1), timeoutMs: z4.number().int().min(1) }).optional()
+  z5.object({ type: z5.literal("workspace.deleted"), workspaceId: z5.string() }),
+  z5.object({
+    type: z5.literal("task.assign"),
+    taskId: z5.string(),
+    workspaceId: z5.string(),
+    adapter: z5.string().min(1),
+    confidential: z5.boolean(),
+    prompt: z5.string(),
+    runToken: z5.string(),
+    hubUrl: z5.string(),
+    pluginTools: z5.array(z5.object({ name: z5.string(), description: z5.string(), parameters: z5.record(z5.string(), z5.unknown()) })),
+    limits: z5.object({ maxModelCalls: z5.number().int().min(1), maxToolCalls: z5.number().int().min(1), timeoutMs: z5.number().int().min(1) }).optional()
   }),
-  z4.object({ type: z4.literal("rpc.request"), id: z4.string(), method: z4.string(), params: z4.unknown() }),
-  z4.object({ type: z4.literal("error"), message: z4.string() })
+  z5.object({ type: z5.literal("rpc.request"), id: z5.string(), method: z5.string(), params: z5.unknown() }),
+  z5.object({ type: z5.literal("error"), message: z5.string() })
 ]);
 function parseHubToDaemon(raw) {
   return HubToDaemonSchema.parse(raw);
@@ -819,6 +957,8 @@ export {
   isBranchName,
   PLUGINS,
   bundledExtensions,
+  parseSkillSource,
+  safeRepoPath,
   parseHubToDaemon,
   parseGhCommand,
   GH_COMMAND_TOOLS

package/dist/daemon/connection.js

@@ -1,6 +1,6 @@
 import {
   parseHubToDaemon
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-W4DUBATU.js";
 
 // daemon/connection.js
 import WebSocket from "ws";

package/dist/direct/tools.js

@@ -1,6 +1,6 @@
 import {
   UpsertEntryInput
-} from "../chunks/chunk-HEIQINX3.js";
+} from "../chunks/chunk-W4DUBATU.js";
 
 // direct/tools.js
 import { z } from "zod";

package/dist/extensions/handlers.d.ts

@@ -1,2 +1,17 @@
 import type { RpcRouter } from "../daemon/rpc.js";
-export declare function registerExtensionHandlers(router: RpcRouter, nemaHome: string): void;
+import { type SkillCandidate, type SkillResolution, type SourceFetch } from "./source.js";
+export type ExtensionRemoval = {
+    id: string;
+    removed: "managed" | "external";
+};
+/** A resolved source as the install preview shows it: where each skill would land, and whether it is already there. */
+export type SourcePreview = SkillResolution & {
+    skills: Array<SkillCandidate & {
+        target: string | null;
+        installed: boolean;
+    }>;
+};
+export type ExtensionHandlerOptions = {
+    fetch?: SourceFetch;
+};
+export declare function registerExtensionHandlers(router: RpcRouter, nemaHome: string, options?: ExtensionHandlerOptions): void;

package/dist/extensions/handlers.js

@@ -1,9 +1,84 @@
+import {
+  parseSkillSource
+} from "../chunks/chunk-W4DUBATU.js";
+
 // extensions/handlers.js
 import path from "node:path";
+import { SkillInstaller } from "./install.js";
+import { resolveSkillSource } from "./source.js";
 import { openExtensionStore } from "./store.js";
-function registerExtensionHandlers(router, nemaHome) {
-  const store = openExtensionStore(path.join(nemaHome, "extensions"));
+var RESOLVE_TIMEOUT_MS = 45e3;
+function requireId(params, method) {
+  const id = params?.id;
+  if (typeof id !== "string" || !id)
+    throw new Error(`${method} needs a string id`);
+  return id;
+}
+function requireUseState(params) {
+  const useState = params?.useState;
+  if (useState !== "enabled" && useState !== "disabled")
+    throw new Error("extensions.setUse needs useState enabled or disabled");
+  return useState;
+}
+function registerExtensionHandlers(router, nemaHome, options = {}) {
+  const root = path.join(nemaHome, "extensions");
+  const store = openExtensionStore(root);
+  const fetch = options.fetch ?? globalThis.fetch;
+  const installer = new SkillInstaller({ root, store, fetch });
+  installer.recover();
   router.register("extensions.list", async () => store.list());
+  router.register("extensions.setUse", async (params) => store.setUseState(requireId(params, "extensions.setUse"), requireUseState(params)));
+  router.register("extensions.remove", async (params) => {
+    const id = requireId(params, "extensions.remove");
+    const record = store.list().find((row) => row.id === id);
+    if (!record)
+      throw new Error(`extension not found: ${id}`);
+    if (installer.running(id))
+      throw new Error(`${id} is installing; cancel the install and wait for it to stop first`);
+    if (record.provision === "bundled")
+      throw new Error("bundled extensions cannot be removed");
+    if (record.provision === "managed") {
+      store.removeManaged(id);
+      installer.forget(id);
+      return { id, removed: "managed" };
+    }
+    store.detach(id);
+    return { id, removed: "external" };
+  });
+  router.register("extensions.resolveSource", async (params) => {
+    const raw = params?.source;
+    if (typeof raw !== "string")
+      throw new Error("extensions.resolveSource needs a string source");
+    const source = parseSkillSource(raw);
+    let resolved;
+    try {
+      resolved = await resolveSkillSource(source, { fetch, signal: AbortSignal.timeout(RESOLVE_TIMEOUT_MS) });
+    } catch (error) {
+      if (error instanceof Error && (error.name === "TimeoutError" || error.name === "AbortError")) {
+        throw new Error(`GitHub did not answer within ${RESOLVE_TIMEOUT_MS / 1e3} s`);
+      }
+      throw error;
+    }
+    const present = new Set(store.list().filter((row) => row.installState === "installed").map((row) => row.id));
+    return {
+      ...resolved,
+      skills: resolved.skills.map((skill) => ({
+        ...skill,
+        target: skill.id ? path.join(root, "extensions", skill.id) : null,
+        installed: skill.id ? present.has(skill.id) : false
+      }))
+    };
+  });
+  router.register("extensions.install", async (params) => {
+    const p = params ?? {};
+    if (typeof p.source !== "string" || typeof p.commit !== "string" || typeof p.path !== "string") {
+      throw new Error("extensions.install needs string source, commit and path");
+    }
+    return installer.start({ source: p.source, commit: p.commit, path: p.path });
+  });
+  router.register("extensions.installStatus", async (params) => installer.status(requireId(params, "extensions.installStatus")));
+  router.register("extensions.cancelInstall", async (params) => installer.cancel(requireId(params, "extensions.cancelInstall")));
+  router.register("extensions.retryInstall", async (params) => installer.retry(requireId(params, "extensions.retryInstall")));
 }
 export {
   registerExtensionHandlers

package/dist/extensions/install.d.ts

@@ -0,0 +1,70 @@
+import { type SourceFetch, type TreeEntry } from "./source.js";
+import type { openExtensionStore } from "./store.js";
+type Store = ReturnType<typeof openExtensionStore>;
+export type InstallState = "running" | "installed" | "failed" | "cancelled";
+/** What the page polls while a skill installs, and what it reads afterwards. */
+export type InstallJob = {
+    id: string;
+    state: InstallState;
+    /** Files written to staging so far, out of `total`. */
+    done: number;
+    total: number;
+    error: string | null;
+    commit: string | null;
+    path: string | null;
+};
+export type InstallRequest = {
+    source: string;
+    commit: string;
+    path: string;
+};
+export declare const INTERRUPTED = "interrupted: the daemon stopped before the install finished";
+/**
+ * The files of one skill folder at one commit, checked before any byte is downloaded: regular files
+ * only, names safe on every platform, no two names that collide on a case-insensitive disk, and
+ * inside the count and size limits.
+ */
+export declare function skillFiles(entries: TreeEntry[], folder: string): Array<TreeEntry & {
+    relative: string;
+}>;
+/**
+ * Installs one skill folder from a pinned commit into Nema's managed directory.
+ *
+ * The record goes in first as `installing`, carrying the commit and folder, so a crash leaves enough
+ * behind for `recover()` to mark it failed and for `retry()` to start again from the same commit.
+ * Files are downloaded into `<root>/staging/<id>-*`, each checked against its Git blob hash, and only
+ * a complete, verified folder is handed to `installManaged`, which swaps it in.
+ */
+export declare class SkillInstaller {
+    private readonly o;
+    private readonly jobs;
+    /** Ids a retry has claimed while it re-reads the recorded commit, before its job exists. */
+    private readonly reserved;
+    private readonly staging;
+    constructor(o: {
+        root: string;
+        store: Store;
+        fetch: SourceFetch;
+        downloadTimeoutMs?: number;
+    });
+    /** Called once at daemon start: no install can be running yet, so every `installing` record is left over. */
+    recover(): string[];
+    /** True from the moment an install or retry is accepted until its cleanup has finished. */
+    running(id: string): boolean;
+    /** Called after a removal, so a finished job is not reported for an extension that is gone. */
+    forget(id: string): void;
+    start(request: InstallRequest): Promise<InstallJob>;
+    private begin;
+    /** Start again from the commit and folder on the record, for a failed, cancelled or interrupted install. */
+    retry(id: string): Promise<InstallJob>;
+    cancel(id: string): InstallJob;
+    status(id: string): InstallJob;
+    /** Resolves once the current install of `id` has stopped, whichever way. For tests and shutdown. */
+    settled(id: string): Promise<void>;
+    /** One install per id at a time; an installed copy is not replaced (updating is its own operation). */
+    private claim;
+    private snapshot;
+    private launch;
+    private run;
+}
+export {};