@treeseed/sdk 0.5.3 → 0.6.1

package/dist/operations/services/github-automation.d.ts

@@ -21,7 +21,7 @@ export declare function parseGitHubRepositoryFromRemote(remoteUrl: any): string
 export declare function resolveGitHubRepositorySlug(tenantRoot: any): string;
 export declare function maybeResolveGitHubRepositorySlug(tenantRoot: any): string | null;
 export declare function resolveDefaultGitHubOwner(): string;
-export declare function createGitHubRepository(input: any): {
+export declare function createGitHubRepository(input: any): Promise<import("./github-api.ts").GitHubRepositorySummary | {
     visibility: any;
     defaultBranch: string;
     mode: string;
@@ -31,16 +31,7 @@ export declare function createGitHubRepository(input: any): {
     sshUrl: string;
     httpsUrl: string;
     url: string;
-} | {
-    owner: string;
-    name: string;
-    url: string;
-    visibility: string;
-    defaultBranch: string;
-    slug: string;
-    sshUrl: string;
-    httpsUrl: string;
-};
+}>;
 export declare function initializeGitHubRepositoryWorkingTree(cwd: any, repository: any, { defaultBranch, createStaging, commitMessage, remoteName, push, }?: {
     defaultBranch?: string | undefined;
     createStaging?: boolean | undefined;
@@ -110,12 +101,12 @@ export declare function ensureStandardizedGitHubWorkflows(tenantRoot: any): ({
     changed: boolean;
     mode?: undefined;
 })[];
-export declare function listGitHubSecretNames(repository: any, tenantRoot: any): Set<unknown>;
-export declare function listGitHubVariableNames(repository: any, tenantRoot: any): Set<unknown>;
+export declare function listGitHubSecretNames(repository: any, tenantRoot: any): Promise<Set<string>>;
+export declare function listGitHubVariableNames(repository: any, tenantRoot: any): Promise<Set<string>>;
 export declare function formatMissingSecretsReport(repository: any, missingSecrets: any, reason?: string): string;
 export declare function ensureGitHubSecrets(tenantRoot: any, { dryRun }?: {
     dryRun?: boolean | undefined;
-}): {
+}): Promise<{
     existing: never[];
     created: never[];
 } | {
@@ -124,12 +115,12 @@ export declare function ensureGitHubSecrets(tenantRoot: any, { dryRun }?: {
 } | {
     existing: string[];
     created: string[];
-};
+}>;
 export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope, purpose }?: {
     dryRun?: boolean | undefined;
     scope?: string | undefined;
     purpose?: string | undefined;
-}): {
+}): Promise<{
     repository: string | null;
     secrets: {
         existing: never[];
@@ -165,10 +156,10 @@ export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope
     };
     skipped?: undefined;
     mode?: undefined;
-};
+}>;
 export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun }?: {
     dryRun?: boolean | undefined;
-}): {
+}): Promise<{
     mode: string;
     workflow: {
         workflowPath: string;
@@ -249,29 +240,24 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun }
         skipped?: undefined;
         mode?: undefined;
     };
-};
+}>;
 export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, }?: {
     workflow?: string | undefined;
     timeoutSeconds?: number | undefined;
     pollSeconds?: number | undefined;
-}): {
+}): Promise<{
     status: string;
-    reason: string;
-    repository: any;
+    repository: string;
     workflow: string;
-    headSha: any;
-    branch: any;
-    runId?: undefined;
-    conclusion?: undefined;
-    url?: undefined;
+    runId: number;
+    headSha: string | null;
+    conclusion: string | null;
+    url: string | null;
 } | {
     status: string;
+    reason: string;
     repository: any;
     workflow: string;
-    runId: any;
     headSha: any;
-    conclusion: any;
-    url: any;
-    reason?: undefined;
-    branch?: undefined;
-};
+    branch: any;
+}>;

package/dist/operations/services/github-automation.js

@@ -3,6 +3,15 @@ import { dirname, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { resolveTreeseedEnvironmentRegistry } from "../../platform/environment.js";
 import { packageRoot, loadCliDeployConfig } from "./runtime-tools.js";
+import {
+  createGitHubApiClient,
+  ensureGitHubRepository,
+  listGitHubRepositorySecretNames,
+  listGitHubRepositoryVariableNames,
+  upsertGitHubRepositorySecret,
+  upsertGitHubRepositoryVariable,
+  waitForGitHubWorkflowRunCompletion
+} from "./github-api.js";
 function envOrNull(key) {
   const value = process.env[key];
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -41,21 +50,6 @@ function runGit(args, { cwd, allowFailure = false, capture = true } = {}) {
   }
   return result;
 }
-function runGh(args, { cwd, allowFailure = false, capture = true, input } = {}) {
-  const result = spawnSync("gh", args, {
-    cwd,
-    stdio: capture || input !== void 0 ? ["pipe", "pipe", "pipe"] : "inherit",
-    encoding: "utf8",
-    input
-  });
-  if (result.error && result.error.code === "ENOENT") {
-    throw new Error("GitHub CLI `gh` is required for Treeseed GitHub automation.");
-  }
-  if (result.status !== 0 && !allowFailure) {
-    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `gh ${args.join(" ")} failed`);
-  }
-  return result;
-}
 function sleepSeconds(seconds) {
   if (!Number.isFinite(seconds) || seconds <= 0) {
     return;
@@ -116,7 +110,7 @@ function resolveDefaultGitHubOwner() {
   }
   return "treeseed-ai";
 }
-function createGitHubRepository(input) {
+async function createGitHubRepository(input) {
   const visibility = input.visibility ?? "private";
   const remotes = resolveGitHubRemoteUrls(input.owner, input.name);
   if (isGitHubAutomationStubbed()) {
@@ -127,42 +121,16 @@ function createGitHubRepository(input) {
       mode: "stub"
     };
   }
-  const existing = runGh(["repo", "view", remotes.slug, "--json", "name,owner,url,isPrivate,defaultBranchRef,visibility"], {
-    allowFailure: true
+  return await ensureGitHubRepository({
+    owner: remotes.owner,
+    name: remotes.name,
+    description: input.description ?? null,
+    homepageUrl: input.homepageUrl ?? null,
+    visibility,
+    topics: Array.isArray(input.topics) ? input.topics.map((topic) => slugifySegment(topic, "treeseed")) : []
+  }, {
+    client: createGitHubApiClient()
   });
-  if (existing.status !== 0) {
-    const args = ["repo", "create", remotes.slug, "--disable-wiki", "--confirm"];
-    if (visibility === "public") {
-      args.push("--public");
-    } else if (visibility === "internal") {
-      args.push("--internal");
-    } else {
-      args.push("--private");
-    }
-    if (input.description) {
-      args.push("--description", input.description);
-    }
-    if (input.homepageUrl) {
-      args.push("--homepage", input.homepageUrl);
-    }
-    runGh(args, { capture: false });
-  }
-  if (Array.isArray(input.topics) && input.topics.length > 0) {
-    runGh(
-      ["repo", "edit", remotes.slug, ...input.topics.flatMap((topic) => ["--add-topic", slugifySegment(topic, "treeseed")])],
-      { capture: false }
-    );
-  }
-  const viewed = runGh(["repo", "view", remotes.slug, "--json", "name,owner,url,isPrivate,defaultBranchRef,visibility"], {});
-  const payload = JSON.parse(viewed.stdout || "{}");
-  return {
-    ...remotes,
-    owner: String(payload.owner?.login ?? remotes.owner),
-    name: String(payload.name ?? remotes.name),
-    url: String(payload.url ?? remotes.url),
-    visibility: String(payload.visibility ?? (payload.isPrivate === true ? "private" : visibility)),
-    defaultBranch: String(payload.defaultBranchRef?.name ?? "main")
-  };
 }
 function initializeGitHubRepositoryWorkingTree(cwd, repository, {
   defaultBranch = "main",
@@ -317,21 +285,13 @@ function ensureStandardizedGitHubWorkflows(tenantRoot) {
   }
   return workflows;
 }
-function listGitHubSecretNames(repository, tenantRoot) {
-  const result = runGh(["secret", "list", "--repo", repository, "--json", "name"], {
-    cwd: tenantRoot
-  });
-  return new Set(
-    JSON.parse(result.stdout || "[]").map((entry) => entry?.name).filter((value) => typeof value === "string" && value.length > 0)
-  );
+async function listGitHubSecretNames(repository, tenantRoot) {
+  void tenantRoot;
+  return await listGitHubRepositorySecretNames(repository, { client: createGitHubApiClient() });
 }
-function listGitHubVariableNames(repository, tenantRoot) {
-  const result = runGh(["variable", "list", "--repo", repository, "--json", "name"], {
-    cwd: tenantRoot
-  });
-  return new Set(
-    JSON.parse(result.stdout || "[]").map((entry) => entry?.name).filter((value) => typeof value === "string" && value.length > 0)
-  );
+async function listGitHubVariableNames(repository, tenantRoot) {
+  void tenantRoot;
+  return await listGitHubRepositoryVariableNames(repository, { client: createGitHubApiClient() });
 }
 function formatMissingSecretsReport(repository, missingSecrets, reason = "missing_local_env") {
   const lines = [
@@ -345,10 +305,10 @@ function formatMissingSecretsReport(repository, missingSecrets, reason = "missin
   }
   return lines.join("\n");
 }
-function ensureGitHubSecrets(tenantRoot, { dryRun = false } = {}) {
-  return ensureGitHubEnvironment(tenantRoot, { dryRun }).secrets;
+async function ensureGitHubSecrets(tenantRoot, { dryRun = false } = {}) {
+  return (await ensureGitHubEnvironment(tenantRoot, { dryRun })).secrets;
 }
-function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", purpose = "save" } = {}) {
+async function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", purpose = "save" } = {}) {
   if (isGitHubAutomationStubbed()) {
     return {
       repository: maybeResolveGitHubRepositorySlug(tenantRoot),
@@ -379,8 +339,9 @@ function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", p
   const required = requiredGitHubEnvironment(tenantRoot, { scope, purpose });
   const requiredSecrets = required.secrets;
   const requiredVariables = required.variables;
-  const existingSecrets = listGitHubSecretNames(repository, tenantRoot);
-  const existingVariables = listGitHubVariableNames(repository, tenantRoot);
+  const client = createGitHubApiClient();
+  const existingSecrets = await listGitHubRepositorySecretNames(repository, { client });
+  const existingVariables = await listGitHubRepositoryVariableNames(repository, { client });
   const missingRemote = requiredSecrets.filter((name) => !existingSecrets.has(name));
   const missingRemoteVariables = requiredVariables.filter((name) => !existingVariables.has(name));
   const missingLocal = missingRemote.filter((name) => !envOrNull(name)).map((name) => ({ name, localEnvPresent: false, remotePresent: false }));
@@ -394,9 +355,7 @@ function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", p
       createdSecrets.push(name);
       continue;
     }
-    runGh(["secret", "set", name, "--repo", repository, "--body", envOrNull(name) ?? ""], {
-      cwd: tenantRoot
-    });
+    await upsertGitHubRepositorySecret(repository, name, envOrNull(name) ?? "", { client });
     createdSecrets.push(name);
   }
   const createdVariables = [];
@@ -405,9 +364,7 @@ function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", p
       createdVariables.push(name);
       continue;
     }
-    runGh(["variable", "set", name, "--repo", repository, "--body", envOrNull(name) ?? ""], {
-      cwd: tenantRoot
-    });
+    await upsertGitHubRepositoryVariable(repository, name, envOrNull(name) ?? "", { client });
     createdVariables.push(name);
   }
   return {
@@ -422,9 +379,9 @@ function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = "prod", p
     }
   };
 }
-function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
+async function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
   const workflows = ensureStandardizedGitHubWorkflows(tenantRoot);
-  const environment = ensureGitHubEnvironment(tenantRoot, { dryRun });
+  const environment = await ensureGitHubEnvironment(tenantRoot, { dryRun });
   return {
     mode: getGitHubAutomationMode(),
     workflow: workflows[0],
@@ -434,7 +391,7 @@ function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
     environment
   };
 }
-function waitForGitHubWorkflowCompletion(tenantRoot, {
+async function waitForGitHubWorkflowCompletion(tenantRoot, {
   repository,
   workflow = "publish.yml",
   headSha,
@@ -453,58 +410,14 @@ function waitForGitHubWorkflowCompletion(tenantRoot, {
     };
   }
   const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutSeconds * 1e3) {
-    const result = runGh([
-      "run",
-      "list",
-      "--repo",
-      repo,
-      "--workflow",
-      workflow,
-      "--limit",
-      "20",
-      "--json",
-      "databaseId,headSha,headBranch,status,conclusion,event,displayTitle,url"
-    ], { cwd: tenantRoot });
-    const runs = JSON.parse(result.stdout || "[]");
-    const match = runs.find((run) => {
-      if (headSha && run?.headSha !== headSha) {
-        return false;
-      }
-      if (branch && run?.headBranch !== branch) {
-        return false;
-      }
-      return true;
-    });
-    if (match?.databaseId) {
-      runGh(["run", "watch", String(match.databaseId), "--repo", repo, "--exit-status"], {
-        cwd: tenantRoot,
-        capture: false
-      });
-      const finalResult = runGh([
-        "run",
-        "view",
-        String(match.databaseId),
-        "--repo",
-        repo,
-        "--json",
-        "status,conclusion,url,workflowName,headSha"
-      ], { cwd: tenantRoot });
-      const finalRun = JSON.parse(finalResult.stdout || "{}");
-      return {
-        status: "completed",
-        repository: repo,
-        workflow,
-        runId: match.databaseId,
-        headSha: finalRun.headSha ?? match.headSha ?? null,
-        conclusion: finalRun.conclusion ?? match.conclusion ?? null,
-        url: finalRun.url ?? match.url ?? null
-      };
-    }
-    sleepSeconds(pollSeconds);
-  }
-  throw new Error(`Timed out waiting for GitHub workflow ${workflow} in ${repo}.`);
+  return await waitForGitHubWorkflowRunCompletion(repo, {
+    client: createGitHubApiClient(),
+    workflow,
+    headSha,
+    branch,
+    timeoutSeconds,
+    pollSeconds
+  });
 }
 export {
   createGitHubRepository,

package/dist/operations/services/key-agent.d.ts

@@ -35,7 +35,22 @@ export type TreeseedKeyAgentStatus = {
     idleTimeoutMs: number;
     idleRemainingMs: number;
 };
+export type TreeseedKeyAgentDiagnostics = {
+    socketPath: string;
+    pidPath: string;
+    socketPresent: boolean;
+    socketKind: 'missing' | 'socket' | 'fifo' | 'file' | 'directory' | 'other';
+    socketConnectable: boolean;
+    healthOk: boolean;
+    daemonPid: number | null;
+    lastError: string | null;
+};
 export type TreeseedKeyAgentCommand = {
+    command: 'health';
+    keyPath: string;
+    socketPath: string;
+    idleTimeoutMs: number;
+} | {
     command: 'status';
     keyPath: string;
     socketPath: string;
@@ -70,9 +85,10 @@ export type TreeseedKeyAgentResponse = {
     message?: string;
     status?: TreeseedKeyAgentStatus;
     machineKey?: string;
+    diagnostics?: TreeseedKeyAgentDiagnostics;
 };
 export declare class TreeseedKeyAgentError extends Error {
-    code: 'locked' | 'unlock_required' | 'unlock_failed' | 'wrapped_key_missing' | 'wrapped_key_migration_required' | 'interactive_required' | 'daemon_unavailable' | 'corrupt_wrapped_key';
+    code: 'locked' | 'unlock_required' | 'unlock_failed' | 'wrapped_key_missing' | 'wrapped_key_migration_required' | 'interactive_required' | 'daemon_unavailable' | 'corrupt_wrapped_key' | 'permission_denied' | 'protocol_error';
     details?: Record<string, unknown>;
     constructor(code: TreeseedKeyAgentError['code'], message: string, details?: Record<string, unknown>);
 }
@@ -102,8 +118,11 @@ export declare function writeWrappedMachineKeyFile(keyPath: string, payload: Tre
 export declare function replaceWrappedMachineKey(keyPath: string, machineKey: Buffer, passphrase: string): TreeseedWrappedMachineKey;
 export declare function getTreeseedKeyAgentPaths(): {
     homeRoot: string;
+    runtimeRoot: string;
     socketPath: string;
+    pidPath: string;
 };
+export declare function inspectTreeseedKeyAgentDiagnostics(socketPath: string): Promise<TreeseedKeyAgentDiagnostics>;
 export declare function handleTreeseedKeyAgentCommand(command: TreeseedKeyAgentCommand, session: TreeseedKeyAgentSessionState): TreeseedKeyAgentResponse;
 export declare function requestTreeseedKeyAgent(command: TreeseedKeyAgentCommand): Promise<TreeseedKeyAgentResponse>;
 export declare function startTreeseedKeyAgentServer(options: {