@treeseed/sdk 0.4.13 → 0.5.1

package/dist/workflow/operations.js

@@ -9,12 +9,20 @@ import {
   checkTreeseedProviderConnections,
   collectTreeseedConfigContext,
   collectTreeseedPrintEnvReport,
+  ensureTreeseedSecretSessionForConfig,
   ensureTreeseedActVerificationTooling,
   ensureTreeseedGitignoreEntries,
   finalizeTreeseedConfig,
   getTreeseedMachineConfigPaths,
-  rotateTreeseedMachineKey
+  inspectTreeseedKeyAgentStatus,
+  loadTreeseedMachineConfig,
+  resolveTreeseedLaunchEnvironment,
+  resolveTreeseedRemoteSession,
+  rotateTreeseedMachineKey,
+  setTreeseedRemoteSession,
+  writeTreeseedMachineConfig
 } from "../operations/services/config-runtime.js";
+import { ControlPlaneClient } from "../control-plane-client.js";
 import { exportTreeseedCodebase } from "../operations/services/export-runtime.js";
 import {
   assertDeploymentInitialized,
@@ -338,7 +346,175 @@ function createTasksResult(cwd) {
       packages
     };
   });
-  return buildWorkflowResult("tasks", cwd, { tasks }, { includeFinalState: false });
+  const workstreams = tasks.map((task) => ({
+    id: task.name,
+    title: task.name.replace(/^task\//u, "").replace(/[-_]+/gu, " "),
+    linkedDirectRefs: [],
+    branch: task.name,
+    local: task.local,
+    remote: task.remote,
+    current: task.current,
+    previewUrl: task.preview.url,
+    lastSaveAt: task.lastCommitDate ?? null,
+    verificationResult: task.dirtyCurrent ? "needs_attention" : task.head ? "ready" : "unknown",
+    stagingCandidate: task.name === STAGING_BRANCH,
+    archived: false
+  }));
+  return buildWorkflowResult("tasks", cwd, { tasks, workstreams }, { includeFinalState: false });
+}
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+async function connectTreeseedMarketProject(helpers, tenantRoot, input, context) {
+  const machineConfig = loadTreeseedMachineConfig(tenantRoot);
+  const marketSettings = machineConfig.settings?.market && typeof machineConfig.settings.market === "object" ? machineConfig.settings.market : {};
+  const remoteSettings = machineConfig.settings?.remote && typeof machineConfig.settings.remote === "object" ? machineConfig.settings.remote : { activeHostId: "official", executionMode: "prefer-local", hosts: [] };
+  const baseUrl = normalizeOptionalString(input.marketBaseUrl) ?? normalizeOptionalString(marketSettings.baseUrl) ?? normalizeOptionalString(remoteSettings.hosts?.find?.((entry) => entry?.official === true)?.baseUrl) ?? normalizeOptionalString(remoteSettings.hosts?.find?.((entry) => entry?.id === remoteSettings.activeHostId)?.baseUrl);
+  if (!baseUrl) {
+    workflowError(
+      "config",
+      "validation_failed",
+      "Treeseed config --connect-market requires a market base URL. Pass --market-base-url or configure an authenticated remote host first."
+    );
+  }
+  const hostId = normalizeOptionalString(marketSettings.hostId) ?? "knowledge-coop";
+  const activeRemoteSession = resolveTreeseedRemoteSession(tenantRoot, hostId) ?? resolveTreeseedRemoteSession(tenantRoot, remoteSettings.activeHostId) ?? resolveTreeseedRemoteSession(tenantRoot, "official");
+  const accessToken = normalizeOptionalString(input.marketAccessToken) ?? normalizeOptionalString(activeRemoteSession?.accessToken);
+  if (!accessToken) {
+    workflowError(
+      "config",
+      "validation_failed",
+      "Treeseed config --connect-market requires a market access token. Authenticate to the Knowledge Coop control-plane first or pass --market-access-token."
+    );
+  }
+  const projectId = normalizeOptionalString(input.marketProjectId) ?? normalizeOptionalString(marketSettings.projectId);
+  if (!projectId) {
+    workflowError(
+      "config",
+      "validation_failed",
+      "Treeseed config --connect-market requires --market-project-id or an existing settings.market.projectId value."
+    );
+  }
+  const teamId = normalizeOptionalString(input.marketTeamId) ?? normalizeOptionalString(marketSettings.teamId);
+  const projectSlug = normalizeOptionalString(input.marketProjectSlug) ?? normalizeOptionalString(marketSettings.projectSlug) ?? normalizeOptionalString(machineConfig.project?.slug) ?? projectId;
+  const teamSlug = normalizeOptionalString(input.marketTeamSlug) ?? normalizeOptionalString(marketSettings.teamSlug);
+  const projectApiBaseUrl = normalizeOptionalString(input.marketProjectApiBaseUrl) ?? normalizeOptionalString(marketSettings.projectApiBaseUrl);
+  const client = new ControlPlaneClient({
+    baseUrl,
+    accessToken
+  });
+  const connectionResult = await client.upsertProjectConnection(projectId, {
+    mode: "hybrid",
+    projectApiBaseUrl,
+    executionOwner: "project_runner",
+    metadata: {
+      pairingSource: "treeseed_config_connect_market",
+      tenantRoot,
+      tenantSlug: normalizeOptionalString(machineConfig.project?.slug),
+      repoSlug: normalizeOptionalString(machineConfig.project?.slug),
+      teamId,
+      teamSlug,
+      projectSlug,
+      connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    rotateRunnerToken: input.rotateRunnerToken === true
+  });
+  const hosts = Array.isArray(remoteSettings.hosts) ? [...remoteSettings.hosts] : [];
+  const updatedHost = {
+    id: hostId,
+    label: "Knowledge Coop",
+    baseUrl,
+    official: false
+  };
+  const existingHostIndex = hosts.findIndex(
+    (entry) => String(entry?.id ?? "") === hostId || String(entry?.baseUrl ?? "").replace(/\/+$/u, "") === baseUrl.replace(/\/+$/u, "")
+  );
+  if (existingHostIndex >= 0) {
+    hosts.splice(existingHostIndex, 1, {
+      ...hosts[existingHostIndex],
+      ...updatedHost
+    });
+  } else {
+    hosts.unshift(updatedHost);
+  }
+  if (normalizeOptionalString(input.marketAccessToken)) {
+    setTreeseedRemoteSession(tenantRoot, {
+      hostId,
+      accessToken,
+      refreshToken: activeRemoteSession?.refreshToken ?? "",
+      expiresAt: activeRemoteSession?.expiresAt ?? "",
+      principal: activeRemoteSession?.principal ?? null
+    });
+  }
+  const runnerHostId = `market-runner:${projectId}`;
+  if (connectionResult.runnerToken) {
+    setTreeseedRemoteSession(tenantRoot, {
+      hostId: runnerHostId,
+      accessToken: connectionResult.runnerToken,
+      refreshToken: "",
+      expiresAt: "",
+      principal: {
+        id: `runner:${projectId}`,
+        displayName: "Knowledge Coop Project Runner",
+        scopes: [],
+        roles: ["project_runner"],
+        permissions: [],
+        metadata: { projectId }
+      }
+    });
+  }
+  machineConfig.settings.remote = {
+    ...remoteSettings,
+    activeHostId: hostId,
+    hosts
+  };
+  machineConfig.settings.market = {
+    baseUrl,
+    hostId,
+    teamId,
+    teamSlug,
+    projectId,
+    projectSlug,
+    projectApiBaseUrl: connectionResult.connection?.projectApiBaseUrl ?? projectApiBaseUrl ?? null,
+    connectionMode: connectionResult.connection?.mode ?? "hybrid",
+    executionOwner: connectionResult.connection?.executionOwner ?? "project_runner",
+    runnerHostId,
+    runnerReady: Boolean(connectionResult.runnerToken || resolveTreeseedRemoteSession(tenantRoot, runnerHostId)?.accessToken),
+    runnerRegisteredAt: connectionResult.connection?.runnerRegisteredAt ?? null,
+    runnerLastSeenAt: connectionResult.connection?.runnerLastSeenAt ?? null,
+    launchPhase: null,
+    lastSuccessfulPhase: null,
+    githubRepository: null,
+    workflowBootstrapReady: false,
+    approvalBlockers: [],
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeTreeseedMachineConfig(tenantRoot, machineConfig);
+  const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
+  return buildWorkflowResult(
+    "config",
+    tenantRoot,
+    {
+      mode: "connect-market",
+      scopes: context.scopes,
+      sync: context.sync,
+      configPath,
+      keyPath,
+      repairs: context.repairs,
+      preflight: context.preflight,
+      toolHealth: context.toolHealth,
+      market: machineConfig.settings.market,
+      connection: connectionResult.connection,
+      runnerTokenIssued: Boolean(connectionResult.runnerToken)
+    },
+    {
+      summary: "Knowledge Coop project pairing completed.",
+      nextSteps: createNextSteps([
+        { operation: "status", reason: "Confirm the new market connection, runner health, and current workstream posture." },
+        { operation: "tasks", reason: "Inspect the branch-backed workstreams that will now sync into the Knowledge Coop UI." }
+      ])
+    }
+  );
 }
 function maybePrint(write, line, stream = "stdout") {
   if (!line) return;
@@ -846,13 +1022,27 @@ async function workflowConfig(helpers, input = {}) {
       const revealSecrets = input.showSecrets === true;
       const printEnvOnly = input.printEnvOnly === true;
       const rotateMachineKeyFlag = input.rotateMachineKey === true;
+      const connectMarketFlag = input.connectMarket === true;
+      const nonInteractive = input.nonInteractive === true;
       const repairs = input.repair === false ? [] : resolveTreeseedWorkflowState(tenantRoot).deployConfigPresent ? applyTreeseedSafeRepairs(tenantRoot) : [];
       const toolHealth = ensureTreeseedActVerificationTooling({
         tenantRoot,
-        installIfMissing: true,
+        installIfMissing: input.installMissingTooling === true,
         env: helpers.context.env,
         write: (line) => maybePrint(helpers.write, line)
       });
+      const secretSession = printEnvOnly && !revealSecrets ? {
+        status: inspectTreeseedKeyAgentStatus(tenantRoot),
+        createdWrappedKey: false,
+        migratedWrappedKey: false,
+        unlockSource: "existing-session"
+      } : await ensureTreeseedSecretSessionForConfig({
+        tenantRoot,
+        interactive: false,
+        env: helpers.context.env,
+        createIfMissing: true,
+        allowMigration: true
+      });
       ensureTreeseedGitignoreEntries(tenantRoot);
       const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
       const contextSnapshot = collectTreeseedConfigContext({
@@ -882,7 +1072,9 @@ async function workflowConfig(helpers, input = {}) {
             reports: reports2,
             repairs,
             preflight,
-            toolHealth
+            toolHealth,
+            context: contextSnapshot,
+            secretSession
           },
           {
             nextSteps: createNextSteps([
@@ -903,7 +1095,9 @@ async function workflowConfig(helpers, input = {}) {
             keyPath: result.keyPath,
             repairs,
             preflight,
-            toolHealth
+            toolHealth,
+            context: contextSnapshot,
+            secretSession
           },
           {
             nextSteps: createNextSteps([
@@ -912,12 +1106,28 @@ async function workflowConfig(helpers, input = {}) {
           }
         );
       }
+      if (connectMarketFlag) {
+        return connectTreeseedMarketProject(helpers, tenantRoot, input, {
+          scopes,
+          sync,
+          repairs,
+          preflight,
+          toolHealth
+        });
+      }
       const explicitUpdates = Array.isArray(input.updates) ? input.updates.map((update) => ({
         scope: update.scope,
         entryId: String(update.entryId ?? ""),
         value: typeof update.value === "string" ? update.value : "",
         reused: update.reused === true
       })) : null;
+      if (!explicitUpdates && !nonInteractive) {
+        workflowError(
+          "config",
+          "validation_failed",
+          "Treeseed config requires interactive input or explicit updates. Re-run in a TTY, or use --non-interactive/--json from the CLI when you want resolved values applied automatically."
+        );
+      }
       const autoUpdates = scopes.flatMap(
         (scope) => contextSnapshot.entriesByScope[scope].map((entry) => ({
           scope,
@@ -926,6 +1136,7 @@ async function workflowConfig(helpers, input = {}) {
           reused: entry.currentValue.length > 0 || entry.suggestedValue.length > 0
         }))
       );
+      maybePrint(helpers.write, "Saving resolved configuration values to machine config...");
       const applyResult = applyTreeseedConfigValues({
         tenantRoot,
         updates: explicitUpdates ?? autoUpdates
@@ -934,6 +1145,12 @@ async function workflowConfig(helpers, input = {}) {
         tenantRoot,
         scopes,
         sync,
+        env: helpers.context.env,
+        onProgress: (line) => maybePrint(helpers.write, line)
+      });
+      const refreshedContext = collectTreeseedConfigContext({
+        tenantRoot,
+        scopes,
         env: helpers.context.env
       });
       const reports = printEnv ? scopes.map((scope) => ({
@@ -960,7 +1177,8 @@ async function workflowConfig(helpers, input = {}) {
           repairs,
           preflight,
           toolHealth,
-          context: contextSnapshot,
+          secretSession,
+          context: refreshedContext,
           result: {
             ...applyResult,
             ...finalizeResult
@@ -1170,7 +1388,11 @@ async function workflowDev(helpers, input = {}) {
       if (input.port !== void 0) {
         args.push("--port", String(input.port));
       }
-      const env = { ...process.env, ...helpers.context.env ?? {} };
+      const env = resolveTreeseedLaunchEnvironment({
+        tenantRoot,
+        scope: "local",
+        baseEnv: { ...process.env, ...helpers.context.env ?? {} }
+      });
       if (input.background) {
         const child = spawn(process.execPath, args, {
           cwd: tenantRoot,

package/dist/workflow-state.d.ts

@@ -51,8 +51,26 @@ export type TreeseedWorkflowState = {
         url: string | null;
         lastDeploymentTimestamp: string | null;
     };
+    webCache: {
+        webHost: string | null;
+        contentHost: string | null;
+        sourcePagePolicy: string | null;
+        contentPagePolicy: string | null;
+        r2ObjectPolicy: string | null;
+        cloudflareRulesManaged: boolean;
+        lastDeployPurgeAt: string | null;
+        lastDeployPurgeCount: number | null;
+        lastContentPurgeAt: string | null;
+        lastContentPurgeCount: number | null;
+    };
     persistentEnvironments: Record<string, {
         initialized: boolean;
+        phase: string;
+        configured: boolean;
+        provisioned: boolean;
+        deployable: boolean;
+        blockers: string[];
+        warnings: string[];
         lastValidatedAt: string | null;
         lastDeploymentTimestamp: string | null;
         lastDeployedUrl: string | null;
@@ -64,6 +82,33 @@ export type TreeseedWorkflowState = {
         copilot: boolean;
         remoteApi: boolean;
     };
+    marketConnection: {
+        configured: boolean;
+        baseUrl: string | null;
+        hostId: string | null;
+        teamId: string | null;
+        teamSlug: string | null;
+        projectId: string | null;
+        projectSlug: string | null;
+        connectionMode: string | null;
+        projectApiBaseUrl: string | null;
+        hubMode: string | null;
+        runtimeMode: string | null;
+        runtimeRegistration: string | null;
+        runtimeAttached: boolean;
+        runtimeReady: boolean;
+        runnerHostId: string | null;
+        runnerReady: boolean;
+        runnerRegisteredAt: string | null;
+        runnerLastSeenAt: string | null;
+        launchPhase: string | null;
+        lastSuccessfulPhase: string | null;
+        githubRepository: string | null;
+        workflowBootstrapReady: boolean;
+        currentWorkstreamId: string | null;
+        verificationPosture: 'ready' | 'blocked' | 'pending';
+        approvalBlockers: string[];
+    };
     managedServices: Record<string, {
         enabled: boolean;
         initialized: boolean;
@@ -75,8 +120,15 @@ export type TreeseedWorkflowState = {
         treeseedConfig: boolean;
         machineConfig: boolean;
         machineKey: boolean;
-        envLocal: boolean;
-        devVars: boolean;
+    };
+    secrets: {
+        keyAgentRunning: boolean;
+        keyAgentUnlocked: boolean;
+        wrappedKeyPresent: boolean;
+        migrationRequired: boolean;
+        idleTimeoutMs: number;
+        idleRemainingMs: number;
+        startupPassphraseConfigured: boolean;
     };
     releaseReady: boolean;
     readiness: {