openpond 0.0.30-bootstrap.0

package/dist/chunks/project-agent-ZPVO25HA.js

@@ -0,0 +1,892 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  PROJECT_SOURCE_UPLOAD_CONCURRENCY,
+  PROJECT_SOURCE_UPLOAD_LIMITS,
+  PROJECT_SOURCE_UPLOAD_MAX_BYTES,
+  PROJECT_SOURCE_UPLOAD_MAX_FILES,
+  PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES,
+  PROJECT_SOURCE_UPLOAD_TRANSPORT,
+  buildAgentEditOpenInput,
+  buildAgentSourceChecksInput,
+  buildAgentSourceConfig,
+  buildAgentSourcePolicy,
+  buildAgentSourcePublishInput,
+  buildAgentUpdateInput,
+  buildAgentUpsertInput,
+  buildCodingWorkItemBackgroundInput,
+  buildCodingWorkItemChatInput,
+  buildCodingWorkItemPromotionInput,
+  buildProjectUpdateInput,
+  buildProjectUpsertInput,
+  collectAgentSdkProjectSourceUploadEntries,
+  collectProjectSourceUploadEntries,
+  mergeProjectSourceUploadEntries,
+  parseAgentEntrypointScope,
+  parseAgentSourceCheckDispatch,
+  parseAgentSourceCheckKind,
+  parseAgentSourceMode,
+  parseAgentTriggerType,
+  parsePositiveLimit,
+  parseProjectSourceType,
+  resolveLocalAgentSdkCommand,
+  resolveProjectSourceUploadBranch
+} from "./chunk-3CC6MH35.js";
+import "./chunk-I6HN3ZGW.js";
+import "./chunk-VQX33YAG.js";
+import "./chunk-LHYK6QO2.js";
+import "./chunk-OG75GMVO.js";
+import "./chunk-BYAPLT37.js";
+import "./chunk-WYDVQOBL.js";
+import {
+  parseSandboxWorkflowModeOption,
+  resolveSandboxClient,
+  runCommand
+} from "./chunk-XSAXENQD.js";
+import "./chunk-5G4E547X.js";
+import {
+  optionString,
+  optionalJsonObject,
+  parseBooleanOption,
+  requiredTeamId
+} from "./chunk-3Y4EL3P6.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/project-agent-formatters.ts
+function isJsonRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function optionalStringField(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function optionalStringArrayField(record, key) {
+  const value = record?.[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function optionalRecordField(record, key) {
+  const value = record?.[key];
+  return isJsonRecord(value) ? value : null;
+}
+function optionalRecordArrayField(record, key) {
+  const value = record?.[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter(isJsonRecord);
+}
+function optionalBooleanField(record, key) {
+  const value = record?.[key];
+  return typeof value === "boolean" ? value : null;
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => Boolean(value)))];
+}
+function activityPayloads(activity) {
+  return activity.map((item) => item.payload).filter(isJsonRecord);
+}
+function compactDeployPlanFromPayloads(payloads) {
+  const payload = payloads.find(
+    (item) => optionalStringField(item, "deployPlanStatus") || optionalBooleanField(item, "canDeploy") !== null || optionalBooleanField(item, "canRun") !== null || optionalStringArrayField(item, "blockedReasons").length > 0 || optionalStringArrayField(item, "staleReasons").length > 0
+  );
+  if (!payload) return null;
+  const checks = isJsonRecord(payload.checks) ? payload.checks : null;
+  const deployPlan = {};
+  const status = optionalStringField(payload, "deployPlanStatus") ?? optionalStringField(payload, "status");
+  const canDeploy = optionalBooleanField(payload, "canDeploy");
+  const canRun = optionalBooleanField(payload, "canRun");
+  const blockedReasons = optionalStringArrayField(payload, "blockedReasons");
+  const staleReasons = optionalStringArrayField(payload, "staleReasons");
+  const artifactPaths = optionalStringArrayField(payload, "artifactPaths");
+  if (status) deployPlan.status = status;
+  if (canRun !== null) deployPlan.canRun = canRun;
+  if (canDeploy !== null) deployPlan.canDeploy = canDeploy;
+  for (const key of ["agentId", "projectId", "sourceRef", "baseSha"]) {
+    const value = optionalStringField(payload, key);
+    if (value) deployPlan[key] = value;
+  }
+  if (blockedReasons.length > 0) deployPlan.blockedReasons = blockedReasons;
+  if (staleReasons.length > 0) deployPlan.staleReasons = staleReasons;
+  if (artifactPaths.length > 0) deployPlan.artifactPaths = artifactPaths;
+  if (checks) deployPlan.checks = checks;
+  return Object.keys(deployPlan).length > 0 ? deployPlan : null;
+}
+function summarizeSourceCheckStatus(workItem, activity) {
+  const payloads = activityPayloads(activity);
+  const deployPlan = payloads.map((payload) => payload.deployPlan).find(isJsonRecord) ?? compactDeployPlanFromPayloads(payloads);
+  const requestedCheckKind = payloads.map(
+    (payload) => optionalStringField(payload, "checkKind") ?? optionalStringField(payload, "requestedCheckKind")
+  ).find(Boolean) ?? null;
+  const traceArtifactRefs = uniqueStrings([
+    optionalStringField(workItem, "traceArtifactRef"),
+    ...payloads.map((payload) => optionalStringField(payload, "traceArtifactRef")),
+    ...payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "traceArtifactRefs")
+    )
+  ]);
+  const evalResultArtifactRefs = uniqueStrings([
+    optionalStringField(workItem, "evalResultArtifactRef"),
+    ...payloads.map(
+      (payload) => optionalStringField(payload, "evalResultArtifactRef")
+    ),
+    ...payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "evalResultArtifactRefs")
+    )
+  ]);
+  const publishBlockers = uniqueStrings([
+    ...optionalStringArrayField(
+      isJsonRecord(deployPlan) ? deployPlan : null,
+      "blockedReasons"
+    ),
+    ...payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "blockedReasons")
+    ),
+    ...payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "publishBlockers")
+    )
+  ]);
+  const sourceMaterialization = payloads.map((payload) => optionalRecordField(payload, "sourceMaterialization")).find(Boolean) ?? null;
+  const setup = payloads.map((payload) => optionalRecordField(payload, "setup")).find(Boolean) ?? null;
+  const sourceUploadMetadata = payloads.map((payload) => optionalRecordField(payload, "sourceUploadMetadata")).find(Boolean) ?? null;
+  const policyDiscovery = payloads.map((payload) => optionalRecordField(payload, "policyDiscovery")).find(Boolean) ?? null;
+  const discoveredRequiredChecks = uniqueStrings([
+    ...payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "discoveredRequiredChecks")
+    ),
+    ...optionalStringArrayField(policyDiscovery, "requiredChecks")
+  ]);
+  const checkRuns = payloads.flatMap(
+    (payload) => optionalRecordArrayField(payload, "checkRuns")
+  );
+  const validation = payloads.map((payload) => optionalRecordField(payload, "validation")).find(Boolean) ?? null;
+  const evalSummary = payloads.map((payload) => optionalRecordField(payload, "eval")).find(Boolean) ?? payloads.map((payload) => optionalRecordField(payload, "evalSummary")).find(Boolean) ?? null;
+  const validatorArtifactRefs = uniqueStrings(
+    payloads.flatMap(
+      (payload) => optionalStringArrayField(payload, "validatorArtifactRefs")
+    )
+  );
+  const patchArtifactRef = payloads.map((payload) => optionalStringField(payload, "patchArtifactRef")).find(Boolean) ?? null;
+  const draftSourceRef = payloads.map((payload) => optionalStringField(payload, "draftSourceRef")).find(Boolean) ?? null;
+  const finalResultState = payloads.map((payload) => optionalStringField(payload, "finalResultState")).find(Boolean) ?? null;
+  return {
+    workItemId: workItem.id,
+    workItemStatus: optionalStringField(workItem, "status"),
+    latestTaskRunId: optionalStringField(workItem, "latestTaskRunId"),
+    latestRuntimeId: optionalStringField(workItem, "latestRuntimeId"),
+    latestSandboxId: optionalStringField(workItem, "latestSandboxId"),
+    sourceMaterialization,
+    sourceUploadMetadata,
+    setup,
+    policyDiscovery,
+    discoveredRequiredChecks,
+    checkRuns,
+    validation,
+    eval: evalSummary,
+    requestedCheckKind,
+    deployPlan,
+    traceArtifactRefs,
+    evalResultArtifactRefs,
+    validatorArtifactRefs,
+    patchArtifactRef,
+    draftSourceRef,
+    finalResultState,
+    publishBlockers
+  };
+}
+function unsafePublicOutputKey(key) {
+  const normalized = key.toLowerCase();
+  return normalized.includes("raw") || normalized === "stdout" || normalized === "stderr" || normalized === "log" || normalized === "logs" || normalized === "events" || normalized === "eventstream" || normalized === "fulloutput" || normalized === "processoutput" || normalized === "tracejson" || normalized === "evaljson" || normalized === "evalresultsjson";
+}
+function compactPublicValue(value) {
+  if (typeof value === "string") {
+    return value.length > 512 ? `${value.slice(0, 512)}...[truncated:${value.length}]` : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 50).map((item) => compactPublicValue(item));
+  }
+  if (isJsonRecord(value)) {
+    const output = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (unsafePublicOutputKey(key)) continue;
+      output[key] = compactPublicValue(item);
+    }
+    return output;
+  }
+  return value;
+}
+function compactRecordFields(record, fields) {
+  if (!record) return null;
+  const output = {};
+  for (const field of fields) {
+    if (!(field in record)) continue;
+    output[field] = compactPublicValue(record[field]);
+  }
+  return Object.keys(output).length > 0 ? output : null;
+}
+function compactWorkItem(workItem) {
+  return compactRecordFields(workItem, [
+    "id",
+    "projectId",
+    "assignedAgentId",
+    "status",
+    "sourceRef",
+    "baseSha",
+    "latestTaskRunId",
+    "latestRuntimeId",
+    "latestSandboxId",
+    "traceArtifactRef",
+    "evalResultArtifactRef",
+    "createdAt",
+    "updatedAt"
+  ]) ?? { id: workItem.id };
+}
+function compactArtifact(artifact) {
+  return compactRecordFields(artifact, [
+    "id",
+    "kind",
+    "ref",
+    "taskRunId",
+    "runtimeId",
+    "sandboxId",
+    "createdAt"
+  ]) ?? {};
+}
+function compactActivityPayload(payload) {
+  return compactRecordFields(payload, [
+    "checkKind",
+    "requestedCheckKind",
+    "deployPlanStatus",
+    "canDeploy",
+    "canRun",
+    "blockedReasons",
+    "staleReasons",
+    "artifactPaths",
+    "agentId",
+    "projectId",
+    "sourceRef",
+    "baseSha",
+    "sourceMaterialization",
+    "sourceUploadMetadata",
+    "setup",
+    "policyDiscovery",
+    "discoveredRequiredChecks",
+    "checkRuns",
+    "validation",
+    "eval",
+    "evalSummary",
+    "traceArtifactRef",
+    "traceArtifactRefs",
+    "evalResultArtifactRef",
+    "evalResultArtifactRefs",
+    "validatorArtifactRefs",
+    "patchArtifactRef",
+    "draftSourceRef",
+    "finalResultState",
+    "publishBlockers"
+  ]);
+}
+function compactWorkItemActivity(activity) {
+  const output = compactRecordFields(activity, [
+    "id",
+    "type",
+    "kind",
+    "status",
+    "summary",
+    "message",
+    "createdAt",
+    "updatedAt"
+  ]) ?? { id: activity.id };
+  const payload = compactActivityPayload(
+    optionalRecordField(activity, "payload")
+  );
+  if (payload) output.payload = payload;
+  return output;
+}
+function compactSourceCheckStatus(status) {
+  return compactRecordFields(status, [
+    "workItemId",
+    "workItemStatus",
+    "latestTaskRunId",
+    "latestRuntimeId",
+    "latestSandboxId",
+    "sourceMaterialization",
+    "sourceUploadMetadata",
+    "setup",
+    "policyDiscovery",
+    "discoveredRequiredChecks",
+    "checkRuns",
+    "validation",
+    "eval",
+    "requestedCheckKind",
+    "deployPlan",
+    "traceArtifactRefs",
+    "evalResultArtifactRefs",
+    "validatorArtifactRefs",
+    "patchArtifactRef",
+    "draftSourceRef",
+    "finalResultState",
+    "publishBlockers"
+  ]) ?? { workItemId: optionalStringField(status, "workItemId") ?? "unknown" };
+}
+function compactWorkItemStatusResult(status) {
+  const sourceCheckStatus = isJsonRecord(status.sourceCheckStatus) ? status.sourceCheckStatus : summarizeSourceCheckStatus(status.workItem, status.activity);
+  return {
+    workItem: compactWorkItem(status.workItem),
+    activity: status.activity.map((item) => compactWorkItemActivity(item)),
+    sourceCheckStatus: compactSourceCheckStatus(sourceCheckStatus)
+  };
+}
+function compactBackgroundResult(result) {
+  const output = {};
+  const workItem = optionalRecordField(result, "workItem");
+  if (workItem) output.workItem = compactWorkItem(workItem);
+  const activity = optionalRecordField(result, "activity");
+  if (activity) {
+    output.activity = compactWorkItemActivity(
+      activity
+    );
+  }
+  for (const key of [
+    "taskRun",
+    "runtime",
+    "session",
+    "link",
+    "toolSummary",
+    "accepted",
+    "status"
+  ]) {
+    if (key in result) output[key] = compactPublicValue(result[key]);
+  }
+  return output;
+}
+function formatProjectLine(project) {
+  const source = project.gitRepo ? `${project.gitOwner ?? "_"}/${project.gitRepo}` : project.internalRepoPath ?? project.templateRepoUrl ?? project.normalizedSourceIdentity;
+  return [
+    project.id,
+    project.status,
+    project.sourceType,
+    project.name,
+    source
+  ].join("  ");
+}
+function formatAgentLine(agent) {
+  const entrypoint = agent.selectedEntrypoint.name ? `${agent.selectedEntrypoint.scope}:${agent.selectedEntrypoint.name}` : agent.selectedEntrypoint.scope;
+  const agentSource = agent.runtimeSource ? [
+    agent.runtimeSource.mode,
+    agent.runtimeSource.publishedSnapshotName ?? agent.runtimeSource.publishedSnapshotId ?? agent.runtimeSource.sourceRef
+  ].filter((value) => Boolean(value)).join(":") : "latest_source";
+  return [
+    agent.id,
+    agent.status,
+    agent.triggerType,
+    agent.defaultWorkflowMode,
+    agentSource,
+    entrypoint,
+    agent.name
+  ].join("  ");
+}
+
+// src/cli/agent-source-workflows.ts
+async function runAgentEditWorkflow(client, options, rest) {
+  const editCommand = rest[1]?.trim();
+  const targetId = rest[2]?.trim();
+  const usage = "usage: agent edit <open|chat|activity|background|request-checks|check-status|checkpoint-result|commit-result|pr-result> <id> --team-id <id>";
+  const teamId = requiredTeamId(options, usage);
+  if (!editCommand || !targetId) {
+    throw new Error(usage);
+  }
+  if (editCommand === "open") {
+    const result = await client.agents.openEditWorkItem(
+      targetId,
+      buildAgentEditOpenInput(targetId, teamId, options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (editCommand === "chat") {
+    const result = await client.workItems.chat(
+      targetId,
+      buildCodingWorkItemChatInput(teamId, options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (editCommand === "activity") {
+    const activity = await client.workItems.activity(targetId, {
+      teamId,
+      limit: parsePositiveLimit(options.limit)
+    });
+    console.log(
+      JSON.stringify(
+        { activity: activity.map((item) => compactWorkItemActivity(item)) },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (editCommand === "background") {
+    const result = await client.workItems.handleBackground(
+      targetId,
+      buildCodingWorkItemBackgroundInput(teamId, options)
+    );
+    console.log(JSON.stringify(compactBackgroundResult(result), null, 2));
+    return;
+  }
+  if (editCommand === "request-checks") {
+    const result = await client.agents.requestSourceChecks(
+      targetId,
+      buildAgentSourceChecksInput(teamId, options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (editCommand === "check-status") {
+    const status = await client.workItems.status(targetId, {
+      teamId,
+      limit: parsePositiveLimit(options.limit),
+      includeArchived: true
+    });
+    console.log(JSON.stringify(compactWorkItemStatusResult(status), null, 2));
+    return;
+  }
+  if (editCommand === "checkpoint-result" || editCommand === "commit-result" || editCommand === "pr-result") {
+    const input = buildCodingWorkItemPromotionInput(teamId, options);
+    const artifact = editCommand === "checkpoint-result" ? await client.workItems.promoteCheckpoint(targetId, input) : editCommand === "commit-result" ? await client.workItems.promoteCommit(targetId, input) : await client.workItems.promotePullRequest(targetId, input);
+    console.log(JSON.stringify({ artifact: compactArtifact(artifact) }, null, 2));
+    return;
+  }
+  throw new Error(usage);
+}
+async function runAgentSourceWorkflow(client, options, rest) {
+  const sourceCommand = rest[1]?.trim();
+  const agentId = rest[2]?.trim();
+  const usage = "usage: agent source <deploy-plan|checks|check-status|manifest-snapshots|publish> <id> --team-id <id>";
+  const teamId = requiredTeamId(options, usage);
+  if (!sourceCommand || !agentId) {
+    throw new Error(usage);
+  }
+  if (sourceCommand === "deploy-plan") {
+    const deployPlan = await client.agents.sourceDeployPlan(agentId, {
+      teamId
+    });
+    console.log(JSON.stringify({ deployPlan }, null, 2));
+    return;
+  }
+  if (sourceCommand === "manifest-snapshots") {
+    const manifestSnapshots = await client.agents.manifestSnapshots(agentId, {
+      teamId,
+      limit: parsePositiveLimit(options.limit)
+    });
+    console.log(JSON.stringify({ manifestSnapshots }, null, 2));
+    return;
+  }
+  if (sourceCommand === "checks") {
+    const result = await client.agents.requestSourceChecks(
+      agentId,
+      buildAgentSourceChecksInput(teamId, options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (sourceCommand === "check-status") {
+    const status = await client.workItems.status(agentId, {
+      teamId,
+      limit: parsePositiveLimit(options.limit),
+      includeArchived: true
+    });
+    console.log(JSON.stringify(compactWorkItemStatusResult(status), null, 2));
+    return;
+  }
+  if (sourceCommand === "publish") {
+    const result = await client.agents.publishSource(
+      agentId,
+      buildAgentSourcePublishInput(teamId, options)
+    );
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  throw new Error(usage);
+}
+
+// src/cli/agent-sdk-local-command.ts
+import path from "node:path";
+var LOCAL_AGENT_SDK_COMMANDS = /* @__PURE__ */ new Set([
+  "inspect",
+  "build",
+  "validate",
+  "eval",
+  "traces"
+]);
+function shouldDelegateLocalAgentSdkCommand(subcommand, options) {
+  if (LOCAL_AGENT_SDK_COMMANDS.has(subcommand)) return true;
+  return subcommand === "run" && !optionString(options, "teamId");
+}
+async function runLocalAgentSdkCommand(options, rest) {
+  const subcommand = rest[0] || "inspect";
+  const cwd = path.resolve(
+    optionString(options, "cwd") || optionString(options, "path") || "."
+  );
+  const args = [subcommand, ...rest.slice(1), "--cwd", cwd];
+  if (parseBooleanOption(options.json)) args.push("--json");
+  appendForwardedOption(args, options, "input", "input");
+  appendForwardedOption(args, options, "inputFile", "input-file");
+  const command = resolveLocalAgentSdkCommand(cwd);
+  const result = await runCommand(command.command, [...command.args, ...args], {
+    cwd,
+    inherit: true
+  });
+  if (result.code !== 0) process.exitCode = result.code ?? 1;
+}
+function appendForwardedOption(args, options, optionKey, cliName) {
+  const value = optionString(options, optionKey);
+  if (value) args.push(`--${cliName}`, value);
+}
+
+// src/cli/agent-command.ts
+async function runAgentCommand(options, rest) {
+  const subcommand = rest[0] || "list";
+  if (shouldDelegateLocalAgentSdkCommand(subcommand, options)) {
+    await runLocalAgentSdkCommand(options, rest);
+    return;
+  }
+  const client = await resolveSandboxClient(options);
+  if (subcommand === "list") {
+    const teamId = requiredTeamId(options, "usage: agent list");
+    const agents = await client.agents.list({ teamId });
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify({ agents }, null, 2));
+      return;
+    }
+    if (agents.length === 0) {
+      console.log("no sandbox agents found");
+      return;
+    }
+    for (const agent of agents) {
+      console.log(formatAgentLine(agent));
+    }
+    return;
+  }
+  if (subcommand === "create" || subcommand === "upsert") {
+    const agent = await client.agents.upsert(buildAgentUpsertInput(options));
+    console.log(JSON.stringify({ agent }, null, 2));
+    return;
+  }
+  if (subcommand === "get") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: agent get <agentId>");
+    if (!agentId) {
+      throw new Error("usage: agent get <agentId> --team-id <id>");
+    }
+    const agent = await client.agents.get(agentId, { teamId });
+    console.log(JSON.stringify({ agent }, null, 2));
+    return;
+  }
+  if (subcommand === "run") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: agent run <agentId>");
+    if (!agentId) {
+      throw new Error("usage: agent run <agentId> --team-id <id>");
+    }
+    const idempotencyKey = optionString(options, "idempotencyKey");
+    const conversationId = optionString(options, "conversationId");
+    const targetProjectId = optionString(options, "targetProjectId");
+    const triggerType = parseAgentTriggerType(options.triggerType);
+    const workflowMode = parseSandboxWorkflowModeOption(options.workflowMode);
+    const inputObject = optionalJsonObject(options, "input", "input");
+    const metadata = optionalJsonObject(options, "metadata", "metadata");
+    const agentSourcePolicy = buildAgentSourcePolicy(options);
+    const result = await client.agents.run(agentId, {
+      teamId,
+      ...conversationId ? { conversationId } : {},
+      ...idempotencyKey ? { idempotencyKey } : {},
+      ...targetProjectId ? { targetProjectId } : {},
+      ...targetProjectId ? { targetProject: { id: targetProjectId } } : {},
+      ...triggerType ? { triggerType } : {},
+      ...workflowMode ? { workflowMode } : {},
+      ...inputObject ? { input: inputObject } : {},
+      ...metadata ? { metadata } : {},
+      ...agentSourcePolicy ? { runtimeSourcePolicy: agentSourcePolicy } : {}
+    });
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (subcommand === "bind-runtime-source" || subcommand === "bind-source") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(
+      options,
+      "usage: agent bind-source <agentId>"
+    );
+    if (!agentId) {
+      throw new Error(
+        "usage: agent bind-source <agentId> --team-id <id> --source-mode latest_source|published_snapshot|auto"
+      );
+    }
+    const agentSource = buildAgentSourceConfig(options);
+    if (!agentSource?.mode) {
+      throw new Error(
+        "usage: agent bind-source <agentId> --team-id <id> --source-mode latest_source|published_snapshot|auto"
+      );
+    }
+    const agent = await client.agents.update(agentId, {
+      teamId,
+      runtimeSource: agentSource
+    });
+    console.log(
+      JSON.stringify({ agent, agentSource: agent.runtimeSource }, null, 2)
+    );
+    return;
+  }
+  if (subcommand === "run-test") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: agent run-test <agentId>");
+    if (!agentId) {
+      throw new Error("usage: agent run-test <agentId> --team-id <id>");
+    }
+    const idempotencyKey = optionString(options, "idempotencyKey");
+    const conversationId = optionString(options, "conversationId");
+    const targetProjectId = optionString(options, "targetProjectId");
+    const inputObject = optionalJsonObject(options, "input", "input");
+    const metadata = optionalJsonObject(options, "metadata", "metadata");
+    const workflowMode = parseSandboxWorkflowModeOption(options.workflowMode);
+    const result = await client.agents.run(agentId, {
+      teamId,
+      ...conversationId ? { conversationId } : {},
+      ...idempotencyKey ? { idempotencyKey } : {},
+      ...targetProjectId ? { targetProjectId } : {},
+      ...targetProjectId ? { targetProject: { id: targetProjectId } } : {},
+      ...workflowMode ? { workflowMode } : {},
+      ...inputObject ? { input: inputObject } : {},
+      metadata: {
+        ...metadata ?? {},
+        source: "agent_run_test"
+      },
+      runtimeSourcePolicy: buildAgentSourcePolicy(
+        options,
+        "diagnostic"
+      )
+    });
+    console.log(
+      JSON.stringify(
+        {
+          resolvedRuntimeSource: result.run.runtimeSource,
+          agent: result.agent,
+          run: result.run,
+          sandbox: result.sandbox ?? null
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "edit") {
+    await runAgentEditWorkflow(client, options, rest);
+    return;
+  }
+  if (subcommand === "source") {
+    await runAgentSourceWorkflow(client, options, rest);
+    return;
+  }
+  if (subcommand === "update") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: agent update <agentId>");
+    if (!agentId) {
+      throw new Error("usage: agent update <agentId> --team-id <id>");
+    }
+    const agent = await client.agents.update(
+      agentId,
+      buildAgentUpdateInput(teamId, options)
+    );
+    console.log(JSON.stringify({ agent }, null, 2));
+    return;
+  }
+  if (subcommand === "archive") {
+    const agentId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: agent archive <agentId>");
+    if (!agentId) {
+      throw new Error("usage: agent archive <agentId> --team-id <id>");
+    }
+    const agent = await client.agents.archive(agentId, { teamId });
+    console.log(JSON.stringify({ agent }, null, 2));
+    return;
+  }
+  throw new Error(
+    "usage: agent <inspect|build|validate|eval|traces|list|create|upsert|get|update|run|run-test|bind-source|source|edit|archive> [--team-id <id>] [--project-id <id>] [--name <name>]"
+  );
+}
+
+// src/cli/project-command.ts
+import path2 from "node:path";
+async function runProjectCommand(options, rest) {
+  const subcommand = rest[0] || "list";
+  const client = await resolveSandboxClient(options);
+  if (subcommand === "list") {
+    const teamId = requiredTeamId(options, "usage: project list");
+    const projects = await client.projects.list({ teamId });
+    if (parseBooleanOption(options.json)) {
+      console.log(JSON.stringify({ projects }, null, 2));
+      return;
+    }
+    if (projects.length === 0) {
+      console.log("no sandbox projects found");
+      return;
+    }
+    for (const project of projects) {
+      console.log(formatProjectLine(project));
+    }
+    return;
+  }
+  if (subcommand === "create" || subcommand === "upsert") {
+    const project = await client.projects.upsert(
+      buildProjectUpsertInput(options)
+    );
+    console.log(JSON.stringify({ project }, null, 2));
+    return;
+  }
+  if (subcommand === "get") {
+    const projectId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: project get <projectId>");
+    if (!projectId) {
+      throw new Error("usage: project get <projectId> --team-id <id>");
+    }
+    const project = await client.projects.get(projectId, { teamId });
+    console.log(JSON.stringify({ project }, null, 2));
+    return;
+  }
+  if (subcommand === "update") {
+    const projectId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: project update <projectId>");
+    if (!projectId) {
+      throw new Error("usage: project update <projectId> --team-id <id>");
+    }
+    const project = await client.projects.update(
+      projectId,
+      buildProjectUpdateInput(teamId, options)
+    );
+    console.log(JSON.stringify({ project }, null, 2));
+    return;
+  }
+  if (subcommand === "sync") {
+    const projectId = rest[1]?.trim();
+    const teamId = requiredTeamId(options, "usage: project sync <projectId>");
+    if (!projectId) {
+      throw new Error("usage: project sync <projectId> --team-id <id>");
+    }
+    const project = await client.projects.sync(projectId, { teamId });
+    console.log(JSON.stringify({ project }, null, 2));
+    return;
+  }
+  if (subcommand === "source-upload" || subcommand === "upload-source") {
+    const projectId = rest[1]?.trim();
+    const teamId = requiredTeamId(
+      options,
+      "usage: project source-upload <projectId>"
+    );
+    if (!projectId) {
+      throw new Error(
+        "usage: project source-upload <projectId> --team-id <id> [--path <dir>]"
+      );
+    }
+    const projectPath = path2.resolve(optionString(options, "path") || ".");
+    const branch = await resolveProjectSourceUploadBranch(projectPath, options);
+    const commitMessage = optionString(options, "commitMessage") || optionString(options, "commit-message") || "Upload OpenPond project source";
+    const collected = await collectProjectSourceUploadEntries(projectPath);
+    const agentSdk = await collectAgentSdkProjectSourceUploadEntries(
+      projectPath,
+      collected.entries
+    );
+    const upload = mergeProjectSourceUploadEntries(collected, agentSdk.entries);
+    const project = await client.projects.uploadSource(projectId, {
+      teamId,
+      entries: upload.entries,
+      ...branch ? { branch } : {},
+      commitMessage
+    });
+    console.log(
+      JSON.stringify(
+        {
+          project,
+          uploaded: {
+            path: projectPath,
+            branch,
+            fileCount: upload.fileCount,
+            totalBytes: upload.totalBytes,
+            limits: upload.limits,
+            transport: upload.transport,
+            ...agentSdk.generatedManifestPath ? {
+              agentSdk: {
+                generatedManifestPath: agentSdk.generatedManifestPath,
+                generatedEntryCount: agentSdk.entries.length,
+                synthesizedOpenPondYaml: agentSdk.synthesizedOpenPondYaml,
+                uploadMetadataPath: agentSdk.uploadMetadataPath,
+                uploadMetadataHash: agentSdk.uploadMetadataHash,
+                commands: agentSdk.uploadMetadata?.commands,
+                dependencySetup: agentSdk.uploadMetadata?.dependencySetup,
+                packageManager: agentSdk.uploadMetadata?.packageManager,
+                sourceTreeMode: agentSdk.uploadMetadata?.sourceTreeMode,
+                artifactHashes: agentSdk.uploadMetadata?.artifactHashes
+              }
+            } : {}
+          }
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  if (subcommand === "archive") {
+    const projectId = rest[1]?.trim();
+    const teamId = requiredTeamId(
+      options,
+      "usage: project archive <projectId>"
+    );
+    if (!projectId) {
+      throw new Error("usage: project archive <projectId> --team-id <id>");
+    }
+    const project = await client.projects.archive(projectId, { teamId });
+    console.log(JSON.stringify({ project }, null, 2));
+    return;
+  }
+  throw new Error(
+    "usage: project <list|create|upsert|get|update|sync|source-upload|archive> [--team-id <id>] [--name <name>]"
+  );
+}
+export {
+  PROJECT_SOURCE_UPLOAD_CONCURRENCY,
+  PROJECT_SOURCE_UPLOAD_LIMITS,
+  PROJECT_SOURCE_UPLOAD_MAX_BYTES,
+  PROJECT_SOURCE_UPLOAD_MAX_FILES,
+  PROJECT_SOURCE_UPLOAD_MAX_FILE_BYTES,
+  PROJECT_SOURCE_UPLOAD_TRANSPORT,
+  buildAgentEditOpenInput,
+  buildAgentSourceChecksInput,
+  buildAgentSourceConfig,
+  buildAgentSourcePolicy,
+  buildAgentSourcePublishInput,
+  buildAgentUpdateInput,
+  buildAgentUpsertInput,
+  buildCodingWorkItemBackgroundInput,
+  buildCodingWorkItemChatInput,
+  buildCodingWorkItemPromotionInput,
+  buildProjectUpdateInput,
+  buildProjectUpsertInput,
+  collectProjectSourceUploadEntries,
+  compactArtifact,
+  compactBackgroundResult,
+  compactWorkItemActivity,
+  compactWorkItemStatusResult,
+  formatAgentLine,
+  formatProjectLine,
+  parseAgentEntrypointScope,
+  parseAgentSourceCheckDispatch,
+  parseAgentSourceCheckKind,
+  parseAgentSourceMode,
+  parseAgentTriggerType,
+  parsePositiveLimit,
+  parseProjectSourceType,
+  resolveLocalAgentSdkCommand,
+  runAgentCommand,
+  runAgentEditWorkflow,
+  runAgentSourceWorkflow,
+  runProjectCommand
+};