@fitlab-ai/agent-infra 0.9.11 → 0.9.13

package/dist/lib/update.js

@@ -43,6 +43,7 @@ async function cmdSync() {
     const sandboxAdded = !config.sandbox;
     const taskAdded = !config.task;
     const labelsAdded = !config.labels;
+    const deliveryAdded = !config.delivery;
     if (platformAdded)
         config.platform = structuredClone(defaults.platform);
     if (sandboxAdded)
@@ -51,6 +52,8 @@ async function cmdSync() {
         config.task = structuredClone(defaults.task);
     if (labelsAdded)
         config.labels = structuredClone(defaults.labels);
+    if (deliveryAdded)
+        config.delivery = structuredClone(defaults.delivery);
     const workflowPlan = planAgentClientReconciliation({
         config: config,
         mutation: { type: 'replace-state', state: normalizedOriginal.state },
@@ -98,6 +101,9 @@ async function cmdSync() {
             if (labelsAdded) {
                 info(`Default labels.in config added to ${CONFIG_PATH}.`);
             }
+            if (deliveryAdded) {
+                info(`Default delivery target added to ${CONFIG_PATH}.`);
+            }
         }
         else {
             info(`File registry changed in ${CONFIG_PATH}.`);
@@ -114,6 +120,9 @@ async function cmdSync() {
         if (hasNewEntries && platformAdded) {
             info(`Default platform config added to ${CONFIG_PATH}.`);
         }
+        if (hasNewEntries && deliveryAdded) {
+            info(`Default delivery target added to ${CONFIG_PATH}.`);
+        }
         ok(`Updated ${CONFIG_PATH}`);
     }
     // done

package/dist/lib/version.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
+import semver from 'semver';
 const packageJsonUrl = [
     new URL('../package.json', import.meta.url),
     new URL('../../package.json', import.meta.url),
@@ -9,8 +10,17 @@ if (!packageJsonUrl) {
 const { version } = JSON.parse(readFileSync(packageJsonUrl, 'utf8'));
 const VERSION = `v${version}`;
 const AGENT_INFRA_VERSION_PATTERN = /^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const LEGACY_COMPATIBILITY_CUTOFF_VERSION = '1.0.0';
 function isValidAgentInfraVersion(value) {
     return typeof value === 'string' && AGENT_INFRA_VERSION_PATTERN.test(value);
 }
-export { VERSION, isValidAgentInfraVersion };
+function isLegacyCompatibilityEnabled(runtimeVersion = VERSION) {
+    const normalized = runtimeVersion.startsWith('v') ? runtimeVersion.slice(1) : runtimeVersion;
+    const parsed = semver.valid(normalized);
+    return parsed !== null && semver.lt(parsed, LEGACY_COMPATIBILITY_CUTOFF_VERSION);
+}
+function legacyCompatibilityError(resource, runtimeVersion = VERSION) {
+    return Object.assign(new Error(`PLATFORM_IDENTITY_LEGACY_UNSUPPORTED: ${resource} requires migration to the current schema before v${LEGACY_COMPATIBILITY_CUTOFF_VERSION} runtime ${runtimeVersion}`), { code: 'PLATFORM_IDENTITY_LEGACY_UNSUPPORTED' });
+}
+export { LEGACY_COMPATIBILITY_CUTOFF_VERSION, VERSION, isLegacyCompatibilityEnabled, isValidAgentInfraVersion, legacyCompatibilityError };
 //# sourceMappingURL=version.js.map

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.9.11",
-  "sourceInputHash": "00e07caf1313615df10d46ae620767d7d15c3cc59712c1da581623057b87e0a6",
-  "internalExecutableBuildHash": "8a481b1d79da5e5f31ef79cd3428f1b51df2b859e70724e50dcc5910f8ee40c6"
+  "packageVersion": "0.9.13",
+  "sourceInputHash": "5e4d3ad1c1e7e3c909489ef59ff318ea9cffe5f538ae37d83923773946357afe",
+  "internalExecutableBuildHash": "c8cabf5c6bc776cdcb9621f712172ebda95ff9b12fb6f67213e18bc0159516fd"
 }

package/lib/agent-clients/adapters/codex-lifecycle/build-identity.ts

@@ -22,6 +22,14 @@ type LifecycleBuildIdentityOptions = Readonly<{
 type LifecycleManifestFiles = Readonly<{
   executableFiles: readonly string[];
   contractFiles: readonly string[];
+  launcherShebang: LifecycleLauncherShebang;
+}>;
+
+type LifecycleLauncherShebang = Readonly<{
+  sourceFile: string;
+  compiledFile: string;
+  canonicalLine: string;
+  acceptedLines: readonly string[];
 }>;
 
 type IdentityVerification = Readonly<{
@@ -53,6 +61,56 @@ function normalizeRelativePath(value: string): string {
   return value.replaceAll('\\', '/');
 }
 
+function isSafeLifecyclePath(value: unknown): value is string {
+  return exactText(value)
+    && value === normalizeRelativePath(value)
+    && !path.isAbsolute(value)
+    && !/^[A-Za-z]:[\\/]/u.test(value)
+    && !value.split('/').includes('..');
+}
+
+function isLifecycleLauncherLine(value: unknown): value is string {
+  return typeof value === 'string'
+    && value.length > 1
+    && value.slice(0, -1).trim() === value.slice(0, -1)
+    && value.startsWith('#!')
+    && value.endsWith('\n')
+    && value.indexOf('\n') === value.length - 1
+    && !value.includes('\r');
+}
+
+function readLifecycleLauncherShebang(
+  value: unknown,
+  executableFiles: readonly string[]
+): LifecycleLauncherShebang {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+  }
+  const policy = value as Record<string, unknown>;
+  if (!isSafeLifecyclePath(policy.sourceFile)
+    || !isSafeLifecyclePath(policy.compiledFile)
+    || !isLifecycleLauncherLine(policy.canonicalLine)
+    || !Array.isArray(policy.acceptedLines)
+    || !policy.acceptedLines.every(isLifecycleLauncherLine)
+    || new Set(policy.acceptedLines).size !== policy.acceptedLines.length
+    || !policy.acceptedLines.includes(policy.canonicalLine)
+    || !executableFiles.includes(policy.sourceFile)
+    || policy.compiledFile !== normalizeRelativePath(path.join(
+      'dist',
+      policy.sourceFile.endsWith('.ts')
+        ? policy.sourceFile.replace(/\.ts$/u, '.js')
+        : policy.sourceFile
+    ))) {
+    throw new Error('Lifecycle manifest launcher shebang policy is invalid');
+  }
+  return Object.freeze({
+    sourceFile: policy.sourceFile,
+    compiledFile: policy.compiledFile,
+    canonicalLine: policy.canonicalLine,
+    acceptedLines: Object.freeze([...policy.acceptedLines])
+  });
+}
+
 function readLifecycleManifestFiles(packageRoot: string): LifecycleManifestFiles {
   const file = path.join(
     packageRoot,
@@ -65,18 +123,21 @@ function readLifecycleManifestFiles(packageRoot: string): LifecycleManifestFiles
   const value = JSON.parse(fs.readFileSync(file, 'utf8')) as {
     executableFiles?: unknown;
     contractFiles?: unknown;
+    launcherShebang?: unknown;
   };
   if (!Array.isArray(value.executableFiles)
     || !Array.isArray(value.contractFiles)
-    || !value.executableFiles.every(exactText)
-    || !value.contractFiles.every(exactText)
+    || !value.executableFiles.every(isSafeLifecyclePath)
+    || !value.contractFiles.every(isSafeLifecyclePath)
     || new Set(value.executableFiles).size !== value.executableFiles.length
     || new Set(value.contractFiles).size !== value.contractFiles.length) {
     throw new Error('Lifecycle manifest file list is invalid');
   }
+  const executableFiles = Object.freeze([...value.executableFiles] as string[]);
   return Object.freeze({
-    executableFiles: Object.freeze([...value.executableFiles] as string[]),
-    contractFiles: Object.freeze([...value.contractFiles] as string[])
+    executableFiles,
+    contractFiles: Object.freeze([...value.contractFiles] as string[]),
+    launcherShebang: readLifecycleLauncherShebang(value.launcherShebang, executableFiles)
   });
 }
 
@@ -94,7 +155,28 @@ function executablePackageRoot(): string {
   }
 }
 
-function hashFiles(root: string, files: readonly string[]): string {
+function normalizeLifecycleLauncherBytes(
+  relative: string,
+  content: Buffer,
+  policy: LifecycleLauncherShebang
+): Buffer {
+  const normalized = normalizeRelativePath(relative);
+  if (normalized !== policy.sourceFile && normalized !== policy.compiledFile) return content;
+  const lineEnd = content.indexOf(0x0a);
+  if (lineEnd < 0) return content;
+  const firstLine = content.subarray(0, lineEnd + 1);
+  if (!policy.acceptedLines.some((line) => Buffer.from(line).equals(firstLine))) return content;
+  return Buffer.concat([
+    Buffer.from(policy.canonicalLine),
+    content.subarray(lineEnd + 1)
+  ]);
+}
+
+function hashFiles(
+  root: string,
+  files: readonly string[],
+  launcherShebang?: LifecycleLauncherShebang
+): string {
   const hash = crypto.createHash('sha256');
   for (const relative of [...new Set(files.map(normalizeRelativePath))].sort()) {
     if (path.isAbsolute(relative) || relative.split(/[\\/]/u).includes('..')) {
@@ -107,7 +189,10 @@ function hashFiles(root: string, files: readonly string[]): string {
     }
     hash.update(relative);
     hash.update('\0');
-    hash.update(fs.readFileSync(file));
+    const content = fs.readFileSync(file);
+    hash.update(launcherShebang
+      ? normalizeLifecycleLauncherBytes(relative, content, launcherShebang)
+      : content);
     hash.update('\0');
   }
   return hash.digest('hex');
@@ -157,7 +242,7 @@ function computeLifecycleBuildIdentity(
   if (!exactText(packageJson.version)) throw new Error('Lifecycle package version is invalid');
   let internalExecutableBuildHash: string;
   if (options.executableFiles) {
-    internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles);
+    internalExecutableBuildHash = hashFiles(repoRoot, options.executableFiles, defaults.launcherShebang);
   } else {
     const manifestFile = path.join(executableRoot, 'dist', 'lifecycle-build-manifest.json');
     if (fs.existsSync(manifestFile)) {
@@ -177,16 +262,25 @@ function computeLifecycleBuildIdentity(
         const compiledFiles = defaults.executableFiles.map((file) =>
           file.endsWith('.ts') ? path.join('dist', file.replace(/\.ts$/u, '.js')) : file
         );
-        if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, compiledFiles)) !== manifest.internalExecutableBuildHash) {
+        if (hashFiles(
+          executableRoot,
+          resolveLifecycleExecutableFiles(executableRoot, compiledFiles),
+          defaults.launcherShebang
+        ) !== manifest.internalExecutableBuildHash) {
           throw new Error('Lifecycle compiled executable build does not match its manifest');
         }
-      } else if (hashFiles(executableRoot, resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles)) !== manifest.sourceInputHash) {
+      } else if (hashFiles(
+        executableRoot,
+        resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles),
+        defaults.launcherShebang
+      ) !== manifest.sourceInputHash) {
         throw new Error('Lifecycle executable build manifest is stale or invalid');
       }
       internalExecutableBuildHash = manifest.internalExecutableBuildHash;
     } else internalExecutableBuildHash = hashFiles(
       executableRoot,
-      resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles)
+      resolveLifecycleExecutableFiles(executableRoot, defaults.executableFiles),
+      defaults.launcherShebang
     );
   }
   return Object.freeze({
@@ -249,6 +343,7 @@ export type {
   IdentityVerification,
   LifecycleIdentityWarning,
   LifecycleBuildIdentity,
+  LifecycleLauncherShebang,
   LifecycleManifestFiles,
   LifecycleBuildIdentityOptions
 };

package/lib/agent-clients/adapters/codex-lifecycle/manifest-files.json

@@ -30,5 +30,16 @@
     ".agents/hooks/lifecycle-delegation.js",
     ".agents/skills/run-task/SKILL.md",
     ".agents/rules/lifecycle-orchestration.md"
-  ]
+  ],
+  "launcherShebang": {
+    "sourceFile": "bin/internal-cli.ts",
+    "compiledFile": "dist/bin/internal-cli.js",
+    "canonicalLine": "#!/usr/bin/env node\n",
+    "acceptedLines": [
+      "#!/usr/bin/env node\n",
+      "#!/opt/homebrew/opt/node/bin/node\n",
+      "#!/usr/local/opt/node/bin/node\n",
+      "#!/home/linuxbrew/.linuxbrew/opt/node/bin/node\n"
+    ]
+  }
 }

package/lib/agent-clients/next-steps.ts

@@ -1,6 +1,7 @@
 import { listEnabledAgentClientAdapters } from './registry.ts';
 import { renderAgentClientInvocation } from './invocation.ts';
 import semver from 'semver';
+import { isTaskScopeSkill } from '../task/skill-scope.ts';
 import type { CustomTUI } from './custom-tuis.ts';
 import type { AgentClientId, AgentClientState } from './types.ts';
 
@@ -45,7 +46,11 @@ function renderNextStepCommands(
   }
 
   const args = [
-    ...(input.taskRef === undefined ? [] : [input.taskRef]),
+    ...(input.taskRef === undefined
+      ? []
+      : isTaskScopeSkill(input.skillName)
+        ? ['--task', input.taskRef]
+        : [input.taskRef]),
     ...(input.version === undefined ? [] : [input.version])
   ];
 

package/lib/decide.ts

@@ -79,11 +79,11 @@ export async function decide(args: string[], options: DecideOptions = {}): Promi
       metadataProvider: () => ({ timestamp: now, agentInfraVersion: options.version ?? VERSION })
     };
     let result;
-    const execute = () => {
+    const execute = async () => {
       let current = applyHumanDecision(request, writeOptions);
       if (current.status !== 'failed' || !parsedDecision.overrideTicket) return current;
       if (!parsedDecision.overrideTarget || !parsedDecision.overrideScope) throw new Error('override ticket requires --override-target and --override-scope');
-      const consumed = consumeHumanOverride({
+      const consumed = await consumeHumanOverride({
         taskRef: resolved.taskId,
         ticketId: parsedDecision.overrideTicket,
         failureId: failureId('decision-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
@@ -102,7 +102,7 @@ export async function decide(args: string[], options: DecideOptions = {}): Promi
       if (consumed.status === 'failed') throw new Error(consumed.error.message);
       return current;
     };
-    result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
     if (result.error) throw new Error(result.error.message);
     return 0;
   } catch (error) {

package/lib/defaults.json

@@ -48,6 +48,10 @@
   "task": {
     "shortIdLength": 2
   },
+  "delivery": {
+    "remote": "origin",
+    "baseRef": "main"
+  },
   "labels": {
     "in": {}
   },

package/lib/git/workflow.ts

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 type CommandResult = { status: number | null; stdout: string; stderr: string };
@@ -105,6 +106,42 @@ function commitExplicitPaths(input: { cwd: string; paths: readonly string[]; mes
   return { status: 'applied' as const, changed: true, snapshot: after.snapshot, operations: [{ name: 'stage', status: 'applied' as const }, { name: 'commit', status: 'applied' as const }], error: null };
 }
 
+function previewCommitTree(input: { cwd: string; paths: readonly string[]; expectedHead: string }) {
+  const invalid = validatePaths(input.paths);
+  if (invalid) return { status: 'failed' as const, tree: null, error: { code: 'GIT_COMMIT_INPUT_INVALID', message: invalid } };
+  const before = inspectGitWorkflow(input.cwd);
+  if (!before.snapshot) return { status: 'failed' as const, tree: null, error: { code: 'GIT_INSPECT_FAILED', message: 'Unable to inspect Git repository' } };
+  if (before.snapshot.head !== input.expectedHead) {
+    return { status: 'failed' as const, tree: null, error: { code: 'GIT_HEAD_MISMATCH', message: `Expected HEAD ${input.expectedHead}, received ${before.snapshot.head}` } };
+  }
+  const selected = new Set(input.paths);
+  const unrelatedStaged = before.snapshot.staged.filter((candidate) => !selected.has(candidate));
+  if (unrelatedStaged.length > 0) {
+    return { status: 'failed' as const, tree: null, error: { code: 'GIT_STAGED_SCOPE_MISMATCH', message: `Unrelated staged paths: ${unrelatedStaged.join(', ')}` } };
+  }
+  const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-preview-index-'));
+  const indexFile = path.join(temporaryDirectory, 'index');
+  const temporaryRunner: GitRunner = (args, cwd) => {
+    const result = spawnSync('git', [...args], {
+      cwd,
+      env: { ...process.env, GIT_INDEX_FILE: indexFile },
+      encoding: 'utf8'
+    });
+    return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+  };
+  try {
+    const read = run(temporaryRunner, input.cwd, ['read-tree', input.expectedHead]);
+    if (read.status !== 0) return { status: 'failed' as const, tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: read.stderr.trim() || 'Unable to prepare a temporary Git index' } };
+    const stage = run(temporaryRunner, input.cwd, ['add', '-A', '--', ...input.paths]);
+    if (stage.status !== 0) return { status: 'failed' as const, tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: stage.stderr.trim() || 'Unable to stage the requested paths in a temporary index' } };
+    const tree = value(temporaryRunner, input.cwd, ['write-tree']);
+    if (!tree) return { status: 'failed' as const, tree: null, error: { code: 'GIT_PREVIEW_FAILED', message: 'Unable to write the temporary Git tree' } };
+    return { status: 'planned' as const, tree, error: null };
+  } finally {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  }
+}
+
 function pushGitRefs(input: { cwd: string; remote: string; refs: readonly string[]; expectedSha?: string }, runner: GitRunner = defaultRunner) {
   if (!input.remote || input.refs.length === 0) return { status: 'failed' as const, changed: false, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [], error: { code: 'GIT_PUSH_INPUT_INVALID', message: 'Remote and refs are required' } };
   const operations: GitOperation[] = [];
@@ -192,5 +229,5 @@ function pushRebasedBranch(input: PushRebasedInput, runner: GitRunner = defaultR
   return { status: 'applied' as const, changed: true, snapshot: inspectGitWorkflow(input.cwd, runner).snapshot, operations: [{ name: 'push-rebased', status: 'applied' as const, ref: input.branch }], error: null };
 }
 
-export { commitExplicitPaths, inspectGitWorkflow, pushGitRefs, pushRebasedBranch };
+export { commitExplicitPaths, inspectGitWorkflow, previewCommitTree, pushGitRefs, pushRebasedBranch };
 export type { CommandResult, GitRunner, PushRebasedInput };

package/lib/init.ts

@@ -32,6 +32,7 @@ type Defaults = {
   files: FileRegistry;
   sandbox: Record<string, unknown>;
   task: { shortIdLength: number };
+  delivery: { remote: string; baseRef: string };
   labels: Record<string, unknown>;
 };
 
@@ -39,10 +40,11 @@ type AgentConfig = {
   project: string;
   org: string;
   language: string;
-  platform: { type: string };
+  platform: { type: string; providers?: Record<string, unknown> };
   templateVersion: string;
   sandbox: Record<string, unknown>;
   task: { shortIdLength: number };
+  delivery: { remote: string; baseRef: string };
   labels: Record<string, unknown>;
   files: FileRegistry;
   agentClients: ReturnType<typeof serializeAgentClients>;
@@ -244,6 +246,7 @@ async function cmdInit(): Promise<void> {
     templateVersion: VERSION,
     sandbox: structuredClone(defaults.sandbox),
     task: structuredClone(defaults.task),
+    delivery: structuredClone(defaults.delivery),
     labels: structuredClone(defaults.labels),
     files: { managed: [], merged: [], ejected: [] },
     agentClients: serializeAgentClients(defaultState)

package/lib/internal/git-workflow.ts

@@ -1,5 +1,5 @@
 import fs from 'node:fs';
-import { inspectGitWorkflow, pushRebasedBranch } from '../git/workflow.ts';
+import { inspectGitWorkflow, previewCommitTree, pushRebasedBranch } from '../git/workflow.ts';
 import { compareReviewTrees, snapshotReview } from '../git/review-snapshot.ts';
 import { resolvePostReviewGlobs } from '../task/review-fingerprint.ts';
 import { executeCommitOperation } from '../task/commit-operation.ts';
@@ -26,6 +26,12 @@ function gitWorkflow(args: string[] = []): void {
     const inputIndex = rest.indexOf('--input');
     const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1]!, 'utf8')) : null;
     result = input ? pushRebasedBranch({ cwd: cwd ?? process.cwd(), ...input }) : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
+  } else if (action === 'preview-tree') {
+    const inputIndex = rest.indexOf('--input');
+    const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1]!, 'utf8')) : null;
+    result = input
+      ? previewCommitTree({ cwd: cwd ?? process.cwd(), paths: input.paths, expectedHead: input.expectedHead })
+      : { status: 'failed', changed: false, error: { code: 'GIT_INPUT_REQUIRED', message: '--input JSON file is required' } };
   } else if (action === 'snapshot' || action === 'compare-trees') {
     const inputIndex = rest.indexOf('--input');
     const input = inputIndex >= 0 && rest[inputIndex + 1] ? JSON.parse(fs.readFileSync(rest[inputIndex + 1]!, 'utf8')) : null;

package/lib/internal/platform-checks.ts

@@ -70,17 +70,17 @@ async function platformChecks(args: string[] = []): Promise<void> {
   };
   const unexpected = Object.keys(values).find((name) => !allowed[operation]!.includes(name));
   if (unexpected) { fail(`${operation} does not accept --${unexpected}`); return; }
-  if (operation === 'inspect') { finish(inspectPullRequestReadiness(taskRef, { cwd })); return; }
+  if (operation === 'inspect') { finish(await inspectPullRequestReadiness(taskRef, { cwd })); return; }
   if (operation === 'resolve-run') {
     if (!values.checkName) { fail('resolve-run requires --check-name'); return; }
-    finish(resolvePlatformCheckRun(taskRef, { cwd, checkName: values.checkName, detailsUrl: values.detailsUrl }));
+    finish(await resolvePlatformCheckRun(taskRef, { cwd, checkName: values.checkName, detailsUrl: values.detailsUrl }));
     return;
   }
   if (operation === 'logs') {
     const run = positive(values.run);
     const job = values.job === undefined ? undefined : positive(values.job);
     if (!run || values.job !== undefined && !job) { fail('logs requires a positive --run and optional positive --job'); return; }
-    finish(fetchPlatformCheckLogs(taskRef, { cwd, run, job: job || undefined }));
+    finish(await fetchPlatformCheckLogs(taskRef, { cwd, run, job: job || undefined }));
     return;
   }
   const intervalSeconds = positive(values.intervalSeconds);

package/lib/internal/platform-comment.ts

@@ -11,7 +11,7 @@ import type { CommentKind } from '../platform/issue-comments.ts';
 import type { PlatformResult } from '../platform/types.ts';
 import { backfillCompletionComments } from '../platform/completion-backfill.ts';
 
-const USAGE = `Usage: agent-infra-internal platform-comment list --issue <N> [--cwd <path>]
+const USAGE = `Usage: agent-infra-internal platform-comment list --issue <token> [--cwd <path>]
        agent-infra-internal platform-comment owner <task-ref> [--cwd <path>]
        agent-infra-internal platform-comment backfill <task-ref> --agent <agent> [--cwd <path>]
        agent-infra-internal platform-comment sync <task-ref> --kind <kind> --agent <agent> [--artifact <file>] [--body-file <path|->] [--status-label <label>] [--backfill] [--cwd <path>]
@@ -52,7 +52,7 @@ function readBodyFile(value: string, cwd: string): string {
   return fs.readFileSync(path.resolve(cwd, value), 'utf8');
 }
 
-function platformComment(args: string[] = []): void {
+async function platformComment(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const operation = args[0];
   if (!operation || !['list', 'owner', 'backfill', 'sync'].includes(operation)) { fail('a valid operation is required'); return; }
@@ -63,17 +63,17 @@ function platformComment(args: string[] = []): void {
   if (parsed.error) { fail(parsed.error); return; }
   const cwd = path.resolve(typeof parsed.values.cwd === 'string' ? parsed.values.cwd : process.cwd());
   if (operation === 'list') {
-    const issue = Number(parsed.values.issue);
-    if (!Number.isInteger(issue) || issue <= 0) { fail('list requires a positive --issue'); return; }
+    const issue = parsed.values.issue;
+    if (typeof issue !== 'string' || !issue) { fail('list requires --issue <token>'); return; }
     const unexpected = Object.keys(parsed.values).find((key) => !['issue', 'cwd'].includes(key));
     if (unexpected) { fail(`list does not accept '--${unexpected}'`); return; }
-    finish(listPlatformComments(issue, cwd));
+    finish(await listPlatformComments(issue, cwd));
     return;
   }
   if (operation === 'owner') {
     const unexpected = Object.keys(parsed.values).find((key) => key !== 'cwd');
     if (unexpected) { fail(`owner does not accept '--${unexpected}'`); return; }
-    finish(checkPlatformCommentOwner(taskRef!, { cwd }));
+    finish(await checkPlatformCommentOwner(taskRef!, { cwd }));
     return;
   }
   if (operation === 'backfill') {
@@ -83,7 +83,7 @@ function platformComment(args: string[] = []): void {
     if (typeof agent !== 'string' || !agent) { fail('backfill requires --agent'); return; }
     const normalizedAgent = normalizeAgentToken(agent);
     if (!normalizedAgent) { fail(`invalid --agent '${agent}': ${AGENT_USAGE_HINT}`); return; }
-    finish(backfillCompletionComments(taskRef!, { cwd, agent: normalizedAgent }));
+    finish(await backfillCompletionComments(taskRef!, { cwd, agent: normalizedAgent }));
     return;
   }
   const kind = parsed.values.kind;
@@ -101,7 +101,7 @@ function platformComment(args: string[] = []): void {
     fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
-  finish(syncPlatformComment(taskRef!, {
+  finish(await syncPlatformComment(taskRef!, {
     kind: kind as CommentKind,
     agent: normalizedAgent,
     artifact: typeof parsed.values.artifact === 'string' ? parsed.values.artifact : undefined,

package/lib/internal/platform-context.ts

@@ -10,7 +10,7 @@ function fail(message: string): void {
   process.exitCode = 1;
 }
 
-function platformContext(args: string[] = []): void {
+async function platformContext(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   if (args[0] !== 'resolve') { fail("operation must be 'resolve'"); return; }
   let cwd = process.cwd();
@@ -24,7 +24,7 @@ function platformContext(args: string[] = []): void {
     seen.add(flag);
     cwd = path.resolve(value);
   }
-  const result = resolvePlatformContext({ cwd });
+  const result = await resolvePlatformContext({ cwd });
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
   if (result.status === 'blocked') process.exitCode = 2;

package/lib/internal/platform-issue.ts

@@ -11,7 +11,7 @@ import type { IssueResult } from '../platform/issues.ts';
 
 const USAGE = `Usage: agent-infra-internal platform-issue inspect <task-ref> [--cwd <path>]
        agent-infra-internal platform-issue create <task-ref> --agent <agent> [--dry-run] [--cwd <path>]
-       agent-infra-internal platform-issue bind <task-ref> --issue <N> --agent <agent> [--dry-run] [--cwd <path>]
+       agent-infra-internal platform-issue bind <task-ref> --issue <token> --agent <agent> [--dry-run] [--cwd <path>]
        agent-infra-internal platform-issue sync <task-ref> --agent <agent> [--status <suffix|none>] [--assignees current|none] [--milestone initial|specific|none] [--issue-type] [--fields] [--requirements] [--in-labels from-diff|none] [--base <branch>] [--state open|closed] [--close-reason completed|not_planned] [--dry-run] [--cwd <path>]
 `;
 
@@ -59,7 +59,7 @@ function oneOf(values: Record<string, string | boolean>, name: string, allowed:
   return value;
 }
 
-function platformIssue(args: string[] = []): void {
+async function platformIssue(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const operation = args[0];
   if (!operation || !['inspect', 'create', 'bind', 'sync'].includes(operation)) { fail('a valid operation is required'); return; }
@@ -75,18 +75,17 @@ function platformIssue(args: string[] = []): void {
   };
   const unexpected = Object.keys(values).find((name) => !allowed[operation]!.includes(name));
   if (unexpected) { fail(`${operation} does not accept --${unexpected}`); return; }
-  if (operation === 'inspect') { finish(inspectPlatformIssue(taskRef, { cwd })); return; }
+  if (operation === 'inspect') { finish(await inspectPlatformIssue(taskRef, { cwd })); return; }
   if (typeof values.agent !== 'string' || !values.agent) { fail(`${operation} requires --agent`); return; }
   const agent = normalizeAgentToken(values.agent);
   if (!agent) { fail(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`); return; }
   values.agent = agent;
   if (operation === 'create') {
-    finish(createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true })); return;
+    finish(await createPlatformIssue(taskRef, { cwd, agent: values.agent, dryRun: values.dryRun === true })); return;
   }
   if (operation === 'bind') {
-    const issue = Number(values.issue);
-    if (!Number.isInteger(issue) || issue <= 0) { fail('bind requires a positive --issue'); return; }
-    finish(bindPlatformIssue(taskRef, { cwd, agent: values.agent, issue, dryRun: values.dryRun === true })); return;
+    if (typeof values.issue !== 'string' || !values.issue) { fail('bind requires --issue <token>'); return; }
+    finish(await bindPlatformIssue(taskRef, { cwd, agent: values.agent, issue: values.issue, dryRun: values.dryRun === true })); return;
   }
   try {
     const assignees = oneOf(values, 'assignees', ['current', 'none']);
@@ -99,7 +98,7 @@ function platformIssue(args: string[] = []): void {
     if (closeReason && state !== 'closed') throw new Error('--close-reason requires --state closed');
     const desiredKeys = ['status', 'assignees', 'milestone', 'issueType', 'fields', 'requirements', 'inLabels', 'state'];
     if (!desiredKeys.some((name) => values[name] !== undefined)) throw new Error('sync requires at least one desired-state option');
-    finish(syncPlatformIssue(taskRef, {
+    finish(await syncPlatformIssue(taskRef, {
       cwd, agent: values.agent, dryRun: values.dryRun === true,
       status: typeof values.status === 'string' ? values.status : undefined,
       assignees: assignees as 'current' | 'none' | undefined,

package/lib/internal/platform-pr-review.ts

@@ -6,9 +6,9 @@ import { listPrReviews, publishPrReview } from '../platform/pr-review.ts';
 import type { PrReviewEvent } from '../platform/pr-review.ts';
 import type { PlatformResult } from '../platform/types.ts';
 
-const USAGE = `Usage: agent-infra-internal platform-pr-review inspect --pr <N> [--cwd <path>]
-       agent-infra-internal platform-pr-review list --pr <N> [--cwd <path>]
-       agent-infra-internal platform-pr-review publish --pr <N> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--dry-run] [--cwd <path>]
+const USAGE = `Usage: agent-infra-internal platform-pr-review inspect --pr <token> [--cwd <path>]
+       agent-infra-internal platform-pr-review list --pr <token> [--cwd <path>]
+       agent-infra-internal platform-pr-review publish --pr <token> --scope <taskId|pr{N}> --round <N> --commit <sha> --event <COMMENT|APPROVE|REQUEST_CHANGES> --body-file <path|-> [--dry-run] [--cwd <path>]
 `;
 
 const BOOLEAN_FLAGS = new Set(['--dry-run']);
@@ -50,7 +50,7 @@ function readBodyFile(value: string, cwd: string): string {
   return value === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(path.resolve(cwd, value), 'utf8');
 }
 
-function platformPrReview(args: string[] = []): void {
+async function platformPrReview(args: string[] = []): Promise<void> {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const operation = args[0];
   if (!operation || !['inspect', 'list', 'publish'].includes(operation)) { fail('a valid operation is required'); return; }
@@ -65,14 +65,14 @@ function platformPrReview(args: string[] = []): void {
   };
   const unexpected = Object.keys(values).find((name) => !allowed[operation]!.includes(name));
   if (unexpected) { fail(`${operation} does not accept --${unexpected}`); return; }
-  const pr = Number(values.pr);
-  if (!Number.isInteger(pr) || pr <= 0) { fail(`${operation} requires a positive --pr`); return; }
+  const pr = values.pr;
+  if (typeof pr !== 'string' || !pr) { fail(`${operation} requires --pr <token>`); return; }
   if (operation === 'inspect') {
-    finish(inspectPlatformPullRequestByNumber(pr, { cwd }));
+    finish(await inspectPlatformPullRequestByNumber(pr, { cwd }));
     return;
   }
   if (operation === 'list') {
-    finish(listPrReviews(pr, { cwd }));
+    finish(await listPrReviews(pr, { cwd }));
     return;
   }
   const scope = typeof values.scope === 'string' ? values.scope : '';
@@ -91,7 +91,7 @@ function platformPrReview(args: string[] = []): void {
     fail(`unable to read body file: ${error instanceof Error ? error.message : String(error)}`);
     return;
   }
-  finish(publishPrReview({
+  finish(await publishPrReview({
     cwd,
     prNumber: pr,
     identity: { scope, round, commitSha: commit },