@treeseed/agent 0.8.5

package/dist/api/project-routes.js

@@ -0,0 +1,585 @@
+import {
+  buildKnowledgeCoopKnowledgePackPackage,
+  buildKnowledgeCoopTemplatePackage,
+  TreeseedWorkflowSdk
+} from "@treeseed/sdk";
+import {
+  getTreeseedMachineConfigPaths,
+  loadCliDeployConfig,
+  loadTreeseedMachineConfig,
+  resolveTreeseedRemoteSession
+} from "@treeseed/sdk/workflow-support";
+import { requireTeamCapability } from "./capabilities.js";
+import { jsonError } from "./http.js";
+function withPrefix(prefix, path) {
+  if (!prefix) return path;
+  return `${prefix}${path}`.replace(/\/{2,}/g, "/");
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "change";
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function asRecords(value) {
+  return Array.isArray(value) ? value : [];
+}
+function readString(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+function readOptionalString(record, ...keys) {
+  const value = readString(record, ...keys);
+  return value || null;
+}
+function inferMessageKind(type, status) {
+  if (status === "failed" || type.includes("failed")) return "warning";
+  if (type.includes("waiting") || type.includes("review") || type.includes("release")) return "action_requested";
+  if (type.includes("release_completed") || type.includes("task_verified")) return "release_readiness";
+  return "informational";
+}
+async function summarizeDirect(sdk, projectId) {
+  const [objectives, questions, notes, proposals, decisions, workstreams, releases] = await Promise.all([
+    sdk.search({ model: "objective", sort: [{ field: "updated_at", direction: "desc" }], limit: 50 }),
+    sdk.search({ model: "question", sort: [{ field: "updated_at", direction: "desc" }], limit: 50 }),
+    sdk.search({ model: "note", sort: [{ field: "updated_at", direction: "desc" }], limit: 50 }),
+    sdk.search({ model: "proposal", sort: [{ field: "updated_at", direction: "desc" }], limit: 50 }),
+    sdk.search({ model: "decision", sort: [{ field: "updated_at", direction: "desc" }], limit: 50 }),
+    sdk.listWorkstreams(projectId),
+    sdk.listReleases(projectId)
+  ]);
+  const workstreamPayload = workstreams.payload ?? [];
+  const releasePayload = releases.payload ?? [];
+  const linkIndex = /* @__PURE__ */ new Map();
+  for (const workstream of workstreamPayload) {
+    for (const ref of workstream.linkedItems) {
+      const key = `${ref.model}:${ref.id}`;
+      const current = linkIndex.get(key) ?? { workstreamIds: [], releaseIds: [] };
+      current.workstreamIds.push(workstream.id);
+      linkIndex.set(key, current);
+    }
+  }
+  for (const release of releasePayload) {
+    for (const workstreamId of release.workstreamIds) {
+      const workstream = workstreamPayload.find((entry) => entry.id === workstreamId);
+      for (const ref of workstream?.linkedItems ?? []) {
+        const key = `${ref.model}:${ref.id}`;
+        const current = linkIndex.get(key) ?? { workstreamIds: [], releaseIds: [] };
+        current.releaseIds.push(release.id);
+        linkIndex.set(key, current);
+      }
+    }
+  }
+  const mapItems = (model, entries) => entries.slice(0, 15).map((entry) => {
+    const id = readString(entry, "id", "slug");
+    const links = linkIndex.get(`${model}:${id}`) ?? { workstreamIds: [], releaseIds: [] };
+    return {
+      model,
+      id,
+      title: readString(entry, "title", "name") || id,
+      status: readOptionalString(entry, "status"),
+      updatedAt: readOptionalString(entry, "updated_at", "updatedAt", "updated"),
+      linkedWorkstreamIds: [...new Set(links.workstreamIds)],
+      linkedReleaseIds: [...new Set(links.releaseIds)]
+    };
+  });
+  return {
+    projectId,
+    objectiveCount: objectives.payload.length,
+    questionCount: questions.payload.length,
+    noteCount: notes.payload.length,
+    proposalCount: proposals.payload.length,
+    decisionCount: decisions.payload.length,
+    savedViews: ["Now", "Blocked", "Ready for research", "Ready for build", "Release-linked"],
+    items: [
+      ...mapItems("objective", objectives.payload),
+      ...mapItems("question", questions.payload),
+      ...mapItems("note", notes.payload),
+      ...mapItems("proposal", proposals.payload),
+      ...mapItems("decision", decisions.payload)
+    ].slice(0, 15)
+  };
+}
+async function summarizeAgents(sdk, projectId) {
+  const [specs, runs, messages] = await Promise.all([
+    sdk.listAgentSpecs({ enabled: true }),
+    sdk.search({ model: "agent_run", sort: [{ field: "startedAt", direction: "desc" }], limit: 100 }),
+    sdk.search({ model: "message", sort: [{ field: "updated_at", direction: "desc" }], limit: 100 })
+  ]);
+  const workstreams = await sdk.listWorkstreams(projectId);
+  const workstreamIds = new Set((workstreams.payload ?? []).map((entry) => entry.id));
+  const agentStatuses = specs.map((spec) => {
+    const latestRun = runs.payload.find((entry) => readString(entry, "agentSlug", "agent_slug") === spec.slug);
+    const latestMessage = messages.payload.find((entry) => readString(entry, "type") && readString(entry, "payloadJson", "payload_json"));
+    return {
+      agentSlug: spec.slug,
+      handler: spec.handler,
+      status: readString(latestRun ?? {}, "status") === "failed" ? "failed" : readString(latestRun ?? {}, "status") === "running" ? "active" : latestRun ? "idle" : "waiting",
+      currentTask: readOptionalString(latestRun ?? {}, "summary"),
+      workstreamId: readOptionalString(latestRun ?? {}, "selectedItemKey"),
+      lastMessage: readOptionalString(latestMessage ?? {}, "type"),
+      lastRunAt: readOptionalString(latestRun ?? {}, "startedAt", "started_at", "finishedAt", "finished_at")
+    };
+  });
+  const messageRecords = messages.payload.map((entry) => {
+    const payloadJson = readString(entry, "payloadJson", "payload_json");
+    let parsed = {};
+    try {
+      parsed = payloadJson ? JSON.parse(payloadJson) : {};
+    } catch {
+      parsed = {};
+    }
+    const workstreamId = typeof parsed.workstreamId === "string" && workstreamIds.has(parsed.workstreamId) ? parsed.workstreamId : null;
+    return {
+      id: String(entry.id ?? ""),
+      agentSlug: readString(parsed, "agentSlug") || readString(entry, "relatedId", "related_id") || "agent",
+      kind: inferMessageKind(readString(entry, "type"), readString(entry, "status")),
+      type: readString(entry, "type"),
+      status: readString(entry, "status") || "pending",
+      summary: readString(parsed, "summary", "message", "failureSummary", "blockingReason") || readString(entry, "type"),
+      workstreamId,
+      releaseId: typeof parsed.releaseId === "string" ? parsed.releaseId : null,
+      createdAt: readString(entry, "updated_at", "updatedAt", "created_at") || nowIso(),
+      metadata: parsed
+    };
+  });
+  return {
+    projectId,
+    agents: agentStatuses,
+    messages: messageRecords
+  };
+}
+async function summarizeProject(sdk, config, principal) {
+  const [direct, workstreams, agents, releases, packages] = await Promise.all([
+    summarizeDirect(sdk, config.projectId),
+    sdk.listWorkstreams(config.projectId),
+    summarizeAgents(sdk, config.projectId),
+    sdk.listReleases(config.projectId),
+    sdk.listSharePackages(config.projectId)
+  ]);
+  const workstreamPayload = workstreams.payload ?? [];
+  const releasePayload = releases.payload ?? [];
+  const packagePayload = packages.payload ?? [];
+  const failedWorkstream = workstreamPayload.find((entry) => entry.verificationStatus === "failed");
+  const releaseReady = releasePayload.find((entry) => entry.state === "ready_to_publish");
+  const publishingDraft = packagePayload.find((entry) => entry.state === "ready_to_publish" || entry.state === "published");
+  let projectConnection = {
+    projectId: config.projectId,
+    connection: null,
+    connected: true,
+    hubMode: null,
+    runtimeMode: null,
+    runtimeRegistration: null,
+    runtimeAttached: false,
+    runtimeReady: true,
+    runnerReady: true,
+    projectApiReady: true,
+    mode: "disconnected"
+  };
+  try {
+    const deployConfig = loadCliDeployConfig(config.repoRoot);
+    const runtimeMode = deployConfig.runtime?.mode ?? "none";
+    const runtimeRegistration = deployConfig.runtime?.registration ?? "none";
+    const registrationEnabled = runtimeRegistration === "optional" || runtimeRegistration === "required";
+    const { configPath } = getTreeseedMachineConfigPaths(config.repoRoot);
+    const machineConfig = configPath ? loadTreeseedMachineConfig(config.repoRoot) : null;
+    const marketSettings = machineConfig?.settings?.market && typeof machineConfig.settings.market === "object" ? machineConfig.settings.market : null;
+    const runnerHostId = typeof marketSettings?.runnerHostId === "string" && marketSettings.runnerHostId.trim() ? marketSettings.runnerHostId.trim() : typeof marketSettings?.projectId === "string" && marketSettings.projectId.trim() ? `market-runner:${marketSettings.projectId.trim()}` : null;
+    const runnerSession = runnerHostId ? resolveTreeseedRemoteSession(config.repoRoot, runnerHostId) : null;
+    const runtimeReady = runtimeMode === "none" || !registrationEnabled || Boolean(
+      marketSettings?.runnerReady === true || typeof runnerSession?.accessToken === "string" && runnerSession.accessToken.length > 0
+    );
+    projectConnection = {
+      projectId: config.projectId,
+      connection: null,
+      connected: true,
+      hubMode: deployConfig.hub?.mode ?? null,
+      runtimeMode,
+      runtimeRegistration,
+      runtimeAttached: runtimeMode !== "none" && (!registrationEnabled || Boolean(marketSettings?.projectId)),
+      runtimeReady,
+      runnerReady: runtimeReady,
+      projectApiReady: deployConfig.runtime?.mode !== "none",
+      mode: runtimeMode === "treeseed_managed" ? "hosted" : runtimeMode === "byo_attached" ? registrationEnabled ? "hybrid" : "self_hosted" : "disconnected"
+    };
+  } catch {
+  }
+  const health = failedWorkstream ? { state: "verification_failing", label: "Verification failing", reason: failedWorkstream.verificationSummary ?? "A workstream verification failed." } : releaseReady ? { state: "release_ready", label: "Release ready", reason: "A release candidate is ready for approval." } : publishingDraft ? { state: "sharing_draft", label: "Sharing draft", reason: "A share package is ready for publishing." } : { state: "working_normally", label: "Working normally", reason: "Project workstreams and agents are operating normally." };
+  const recentActivity = [
+    ...workstreamPayload.map((entry) => ({
+      kind: "workstream",
+      id: entry.id,
+      title: entry.title,
+      status: entry.state,
+      timestamp: entry.updatedAt,
+      summary: entry.summary ?? entry.verificationSummary,
+      metadata: { branchName: entry.branchName, linkedItems: entry.linkedItems }
+    })),
+    ...releasePayload.map((entry) => ({
+      kind: "release",
+      id: entry.id,
+      title: entry.title ?? entry.version,
+      status: entry.state,
+      timestamp: entry.updatedAt,
+      summary: entry.summary,
+      metadata: { version: entry.version, releaseTag: entry.releaseTag }
+    })),
+    ...agents.messages.map((entry) => ({
+      kind: "agent_message",
+      id: entry.id,
+      title: entry.type,
+      status: entry.status,
+      timestamp: entry.createdAt,
+      summary: entry.summary,
+      metadata: entry.metadata ?? {}
+    }))
+  ].sort((left, right) => String(right.timestamp ?? "").localeCompare(String(left.timestamp ?? ""))).slice(0, 20);
+  return {
+    projectId: config.projectId,
+    teamId: String(principal?.metadata?.teamId ?? config.projectId),
+    health,
+    counts: {
+      objectives: direct.objectiveCount,
+      questions: direct.questionCount,
+      notes: direct.noteCount,
+      proposals: direct.proposalCount,
+      decisions: direct.decisionCount,
+      activeWorkstreams: workstreamPayload.filter((entry) => entry.state !== "archived").length,
+      agents: agents.agents.length,
+      releases: releasePayload.length
+    },
+    connection: {
+      ...projectConnection
+    },
+    nextBestAction: releaseReady ? "Review the ready release and decide whether to publish." : failedWorkstream ? "Inspect the latest failed verification and update the workstream." : "Open Direct or Workstreams to continue work.",
+    recentActivity
+  };
+}
+function registerProjectRoutes(app, options) {
+  const prefix = options.prefix ?? "";
+  const workflow = new TreeseedWorkflowSdk({
+    cwd: options.config.repoRoot,
+    env: process.env,
+    transport: "api"
+  });
+  app.get(withPrefix(prefix, "/v1/project/summary"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    return c.json({
+      ok: true,
+      payload: await summarizeProject(options.sharedSdk, options.config, principal)
+    });
+  });
+  app.get(withPrefix(prefix, "/v1/direct/summary"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    return c.json({ ok: true, payload: await summarizeDirect(options.sharedSdk, options.config.projectId) });
+  });
+  app.get(withPrefix(prefix, "/v1/workstreams"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const items = await options.sharedSdk.listWorkstreams(options.config.projectId);
+    return c.json({
+      ok: true,
+      payload: {
+        projectId: options.config.projectId,
+        items: items.payload,
+        columns: ["Drafting", "Active locally", "Verifying", "Saved remotely", "In staging", "Archived"]
+      }
+    });
+  });
+  app.post(withPrefix(prefix, "/v1/workstreams"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "manage_workstreams");
+    if (unauthorized) return unauthorized;
+    const body = await c.req.json().catch(() => ({}));
+    const title = typeof body.title === "string" && body.title.trim() ? body.title.trim() : "Untitled change";
+    const branchName = typeof body.branchName === "string" && body.branchName.trim() ? body.branchName.trim() : `task/${slugify(title)}`;
+    await workflow.switchTask({
+      branchName,
+      createIfMissing: true,
+      preview: body.preview === true
+    });
+    const workstream = await options.sharedSdk.upsertWorkstream({
+      projectId: options.config.projectId,
+      title,
+      summary: typeof body.summary === "string" ? body.summary : null,
+      state: "active_local",
+      branchName,
+      branchRef: `refs/heads/${branchName}`,
+      owner: typeof body.owner === "string" ? body.owner : c.get("principal")?.displayName ?? null,
+      linkedItems: Array.isArray(body.linkedItems) ? body.linkedItems : [],
+      metadata: typeof body.metadata === "object" && body.metadata ? body.metadata : {}
+    });
+    if (workstream.payload) {
+      await options.sharedSdk.appendWorkstreamEvent({
+        projectId: options.config.projectId,
+        workstreamId: workstream.payload.id,
+        kind: "created",
+        summary: "Workstream created and branch activated.",
+        data: { branchName }
+      });
+    }
+    return c.json({ ok: true, payload: workstream.payload }, { status: 201 });
+  });
+  app.get(withPrefix(prefix, "/v1/workstreams/:id"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const detail = await options.sharedSdk.getWorkstream(c.req.param("id"));
+    if (!detail.payload) return jsonError(c, 404, `Unknown workstream "${c.req.param("id")}".`);
+    return c.json({ ok: true, payload: detail.payload });
+  });
+  app.post(withPrefix(prefix, "/v1/workstreams/:id/save"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "manage_workstreams");
+    if (unauthorized) return unauthorized;
+    const existing = await options.sharedSdk.getWorkstream(c.req.param("id"));
+    if (!existing.payload) return jsonError(c, 404, `Unknown workstream "${c.req.param("id")}".`);
+    const body = await c.req.json().catch(() => ({}));
+    const result = await workflow.save({
+      message: typeof body.message === "string" && body.message.trim() ? body.message.trim() : `Save ${existing.payload.title}`,
+      verify: body.verify !== false,
+      refreshPreview: body.refreshPreview === true
+    });
+    const updated = await options.sharedSdk.upsertWorkstream({
+      ...existing.payload,
+      state: body.verify === false ? "saved_remote" : "verifying",
+      lastSaveAt: nowIso(),
+      verificationStatus: result.ok ? "completed" : "failed",
+      verificationSummary: result.summary ?? null
+    });
+    await options.sharedSdk.appendWorkstreamEvent({
+      projectId: options.config.projectId,
+      workstreamId: existing.payload.id,
+      kind: "saved",
+      summary: result.summary ?? "Workstream saved.",
+      data: { workflow: result.payload ?? {} }
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.post(withPrefix(prefix, "/v1/workstreams/:id/stage"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "stage_releases");
+    if (unauthorized) return unauthorized;
+    const existing = await options.sharedSdk.getWorkstream(c.req.param("id"));
+    if (!existing.payload) return jsonError(c, 404, `Unknown workstream "${c.req.param("id")}".`);
+    const body = await c.req.json().catch(() => ({}));
+    const result = await workflow.stage({
+      message: typeof body.message === "string" && body.message.trim() ? body.message.trim() : `Stage ${existing.payload.title}`
+    });
+    const updated = await options.sharedSdk.upsertWorkstream({
+      ...existing.payload,
+      state: "in_staging",
+      lastStageAt: nowIso(),
+      verificationStatus: result.ok ? "completed" : existing.payload.verificationStatus,
+      verificationSummary: result.summary ?? existing.payload.verificationSummary
+    });
+    await options.sharedSdk.appendWorkstreamEvent({
+      projectId: options.config.projectId,
+      workstreamId: existing.payload.id,
+      kind: "staged",
+      summary: result.summary ?? "Workstream moved to staging.",
+      data: { workflow: result.payload ?? {} }
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.post(withPrefix(prefix, "/v1/workstreams/:id/archive"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "manage_workstreams");
+    if (unauthorized) return unauthorized;
+    const existing = await options.sharedSdk.getWorkstream(c.req.param("id"));
+    if (!existing.payload) return jsonError(c, 404, `Unknown workstream "${c.req.param("id")}".`);
+    const updated = await options.sharedSdk.upsertWorkstream({
+      ...existing.payload,
+      state: "archived",
+      archivedAt: nowIso()
+    });
+    await options.sharedSdk.appendWorkstreamEvent({
+      projectId: options.config.projectId,
+      workstreamId: existing.payload.id,
+      kind: "archived",
+      summary: "Workstream archived.",
+      data: {}
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.get(withPrefix(prefix, "/v1/releases"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const releases = await options.sharedSdk.listReleases(options.config.projectId);
+    const history = releases.payload;
+    return c.json({
+      ok: true,
+      payload: {
+        projectId: options.config.projectId,
+        history,
+        currentProd: history.find((entry) => entry.state === "published") ?? null,
+        stagingCandidates: history.filter((entry) => entry.state === "ready_to_publish" || entry.state === "waiting_on_verification")
+      }
+    });
+  });
+  app.post(withPrefix(prefix, "/v1/releases"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "stage_releases");
+    if (unauthorized) return unauthorized;
+    const body = await c.req.json().catch(() => ({}));
+    const workstreams = await options.sharedSdk.listWorkstreams(options.config.projectId);
+    const selectedIds = Array.isArray(body.workstreamIds) ? body.workstreamIds.map(String) : workstreams.payload.filter((entry) => entry.state === "in_staging").map((entry) => entry.id);
+    const release = await options.sharedSdk.upsertRelease({
+      projectId: options.config.projectId,
+      version: typeof body.version === "string" && body.version.trim() ? body.version.trim() : `draft-${Date.now()}`,
+      title: typeof body.title === "string" ? body.title : null,
+      state: "ready_to_publish",
+      summary: typeof body.summary === "string" ? body.summary : null,
+      workstreamIds: selectedIds,
+      items: selectedIds.map((workstreamId) => ({
+        id: `${workstreamId}-item`,
+        workstreamId,
+        model: null,
+        recordId: null,
+        summary: "Included workstream",
+        createdAt: nowIso(),
+        metadata: {}
+      }))
+    });
+    return c.json({ ok: true, payload: release.payload }, { status: 201 });
+  });
+  app.get(withPrefix(prefix, "/v1/releases/:id"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const release = await options.sharedSdk.getRelease(c.req.param("id"));
+    if (!release.payload) return jsonError(c, 404, `Unknown release "${c.req.param("id")}".`);
+    return c.json({ ok: true, payload: release.payload });
+  });
+  app.post(withPrefix(prefix, "/v1/releases/:id/publish"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "publish_releases");
+    if (unauthorized) return unauthorized;
+    const release = await options.sharedSdk.getRelease(c.req.param("id"));
+    if (!release.payload) return jsonError(c, 404, `Unknown release "${c.req.param("id")}".`);
+    const body = await c.req.json().catch(() => ({}));
+    const workflowResult = await workflow.release({
+      bump: body.bump === "major" || body.bump === "minor" ? body.bump : "patch"
+    });
+    const updated = await options.sharedSdk.upsertRelease({
+      ...release.payload,
+      state: "published",
+      publishedAt: nowIso(),
+      releaseTag: readOptionalString(workflowResult.payload ?? {}, "version", "releaseTag")
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.post(withPrefix(prefix, "/v1/releases/:id/rollback"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "publish_releases");
+    if (unauthorized) return unauthorized;
+    const release = await options.sharedSdk.getRelease(c.req.param("id"));
+    if (!release.payload) return jsonError(c, 404, `Unknown release "${c.req.param("id")}".`);
+    const updated = await options.sharedSdk.upsertRelease({
+      ...release.payload,
+      state: "rolled_back",
+      rolledBackAt: nowIso()
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.get(withPrefix(prefix, "/v1/share/status"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const packages = await options.sharedSdk.listSharePackages(options.config.projectId);
+    return c.json({
+      ok: true,
+      payload: {
+        projectId: options.config.projectId,
+        packages: packages.payload,
+        listing: null,
+        canPublish: packages.payload.some((entry) => entry.state === "ready_to_publish" || entry.state === "published")
+      }
+    });
+  });
+  for (const [path, kind] of [
+    ["/v1/share/export", "export"],
+    ["/v1/share/package-template", "template"],
+    ["/v1/share/package-knowledge-pack", "knowledge_pack"]
+  ]) {
+    app.post(withPrefix(prefix, path), async (c) => {
+      const unauthorized = requireTeamCapability(c, "manage_products");
+      if (unauthorized) return unauthorized;
+      const body = await c.req.json().catch(() => ({}));
+      const exportResult = kind === "export" ? await workflow.export({
+        directory: typeof body.directory === "string" ? body.directory : void 0
+      }) : null;
+      const packageResult = kind === "template" ? buildKnowledgeCoopTemplatePackage(options.config.repoRoot, {
+        id: typeof body.id === "string" ? body.id : void 0,
+        title: typeof body.title === "string" && body.title.trim() ? body.title.trim() : void 0,
+        summary: typeof body.summary === "string" ? body.summary : null,
+        outputRoot: typeof body.outputRoot === "string" ? body.outputRoot : null,
+        projectSlug: typeof body.projectSlug === "string" ? body.projectSlug : options.config.projectId,
+        market: {
+          publisherId: typeof c.get("principal")?.metadata?.teamId === "string" ? c.get("principal").metadata.teamId : null,
+          publisherName: typeof c.get("principal")?.displayName === "string" ? c.get("principal").displayName : null,
+          publishMetadata: {
+            projectId: options.config.projectId,
+            kind
+          }
+        }
+      }) : kind === "knowledge_pack" ? buildKnowledgeCoopKnowledgePackPackage(options.config.repoRoot, {
+        id: typeof body.id === "string" ? body.id : void 0,
+        title: typeof body.title === "string" && body.title.trim() ? body.title.trim() : void 0,
+        summary: typeof body.summary === "string" ? body.summary : null,
+        outputRoot: typeof body.outputRoot === "string" ? body.outputRoot : null,
+        projectSlug: typeof body.projectSlug === "string" ? body.projectSlug : options.config.projectId,
+        includePaths: Array.isArray(body.includePaths) ? body.includePaths.map(String) : void 0,
+        market: {
+          publisherId: typeof c.get("principal")?.metadata?.teamId === "string" ? c.get("principal").metadata.teamId : null,
+          publisherName: typeof c.get("principal")?.displayName === "string" ? c.get("principal").displayName : null,
+          publishMetadata: {
+            projectId: options.config.projectId,
+            kind
+          }
+        }
+      }) : null;
+      const item = await options.sharedSdk.upsertSharePackage({
+        projectId: options.config.projectId,
+        kind,
+        title: typeof body.title === "string" && body.title.trim() ? body.title.trim() : `${kind}-${Date.now()}`,
+        summary: kind === "export" ? exportResult?.summary ?? null : packageResult?.manifest.summary ?? null,
+        state: "ready_to_publish",
+        version: kind === "export" ? null : packageResult?.manifest.version ?? null,
+        outputPath: kind === "export" ? readOptionalString(exportResult?.payload ?? {}, "path", "outputPath", "directory") : packageResult?.outputRoot ?? null,
+        artifactKey: kind === "export" ? null : packageResult?.payloadRoot ?? null,
+        manifestKey: kind === "export" ? null : packageResult?.manifestPath ?? null,
+        metadata: kind === "export" ? typeof exportResult?.payload === "object" && exportResult.payload ? exportResult.payload : {} : {
+          manifest: packageResult?.manifest ?? null,
+          files: packageResult?.files ?? [],
+          payloadRoot: packageResult?.payloadRoot ?? null
+        }
+      });
+      return c.json({ ok: true, payload: item.payload });
+    });
+  }
+  app.post(withPrefix(prefix, "/v1/share/publish"), async (c) => {
+    const unauthorized = requireTeamCapability(c, "publish_market_listings");
+    if (unauthorized) return unauthorized;
+    const body = await c.req.json().catch(() => ({}));
+    const sharePackage = typeof body.packageId === "string" ? await options.sharedSdk.getSharePackage(body.packageId) : null;
+    if (!sharePackage?.payload) {
+      return jsonError(c, 404, "Unknown share package.");
+    }
+    const updated = await options.sharedSdk.upsertSharePackage({
+      ...sharePackage.payload,
+      state: "published"
+    });
+    return c.json({ ok: true, payload: updated.payload });
+  });
+  app.get(withPrefix(prefix, "/v1/agents/status"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const payload = await summarizeAgents(options.sharedSdk, options.config.projectId);
+    return c.json({ ok: true, payload: { projectId: options.config.projectId, agents: payload.agents } });
+  });
+  app.get(withPrefix(prefix, "/v1/agents/messages"), async (c) => {
+    const principal = c.get("principal");
+    if (!principal) return jsonError(c, 401, "Authentication required.");
+    const payload = await summarizeAgents(options.sharedSdk, options.config.projectId);
+    return c.json({ ok: true, payload: payload.messages });
+  });
+}
+export {
+  registerProjectRoutes
+};

package/dist/api/providers.d.ts

@@ -0,0 +1,2 @@
+import type { ApiConfig, ApiRuntimeProviders, ResolvedApiRuntimeProviders } from './types.ts';
+export declare function resolveApiRuntimeProviders(config: ApiConfig, overrides?: ApiRuntimeProviders): ResolvedApiRuntimeProviders;

package/dist/api/providers.js

@@ -0,0 +1,62 @@
+import { MemoryDeviceCodeAuthProvider } from "./auth/memory-provider.js";
+import { D1AuthProvider } from "./auth/d1-provider.js";
+import { resolveApiD1Database } from "./auth/d1-database.js";
+function addProviders(target, incoming, label) {
+  for (const [id, value] of Object.entries(incoming ?? {})) {
+    if (target.has(id)) {
+      throw new Error(`Treeseed API runtime found duplicate ${label} provider "${id}".`);
+    }
+    target.set(id, value);
+  }
+}
+function resolveSelectedProvider(registry, selectedId, label) {
+  const selected = registry.get(selectedId);
+  if (!selected) {
+    throw new Error(`Treeseed API runtime could not resolve ${label} provider "${selectedId}".`);
+  }
+  return selected;
+}
+function resolveApiRuntimeProviders(config, overrides = {}) {
+  const authRegistry = /* @__PURE__ */ new Map();
+  const agentExecution = /* @__PURE__ */ new Map();
+  const agentQueue = /* @__PURE__ */ new Map();
+  const agentNotification = /* @__PURE__ */ new Map();
+  const agentRepository = /* @__PURE__ */ new Map();
+  const agentVerification = /* @__PURE__ */ new Map();
+  addProviders(authRegistry, {
+    memory: ({ config: runtimeConfig }) => new MemoryDeviceCodeAuthProvider(runtimeConfig),
+    d1: ({ config: runtimeConfig }) => new D1AuthProvider(runtimeConfig, { db: resolveApiD1Database(runtimeConfig) })
+  }, "auth");
+  addProviders(authRegistry, overrides.auth, "auth");
+  addProviders(agentExecution, { stub: { id: "stub" } }, "agent execution");
+  addProviders(agentQueue, { memory: { id: "memory" } }, "agent queue");
+  addProviders(agentNotification, { stub: { id: "stub" } }, "agent notification");
+  addProviders(agentRepository, { stub: { id: "stub" } }, "agent repository");
+  addProviders(agentVerification, { stub: { id: "stub" } }, "agent verification");
+  addProviders(agentExecution, overrides.agentExecution, "agent execution");
+  addProviders(agentQueue, overrides.agentQueue, "agent queue");
+  addProviders(agentNotification, overrides.agentNotification, "agent notification");
+  addProviders(agentRepository, overrides.agentRepository, "agent repository");
+  addProviders(agentVerification, overrides.agentVerification, "agent verification");
+  const authFactory = resolveSelectedProvider(authRegistry, config.providers.auth, "auth");
+  resolveSelectedProvider(agentExecution, config.providers.agents.execution, "agent execution");
+  resolveSelectedProvider(agentQueue, config.providers.agents.queue, "agent queue");
+  resolveSelectedProvider(agentNotification, config.providers.agents.notification, "agent notification");
+  resolveSelectedProvider(agentRepository, config.providers.agents.repository, "agent repository");
+  resolveSelectedProvider(agentVerification, config.providers.agents.verification, "agent verification");
+  return {
+    auth: authFactory({ config }),
+    registries: {
+      auth: authRegistry,
+      agentExecution,
+      agentQueue,
+      agentNotification,
+      agentRepository,
+      agentVerification
+    },
+    selections: config.providers
+  };
+}
+export {
+  resolveApiRuntimeProviders
+};