taskode 0.4.0

package/src/workflow.js

@@ -0,0 +1,339 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import yaml from 'js-yaml';
+
+const DEFAULT_WORKSPACE_IGNORES = ['.git', '.taskode', 'node_modules'];
+const VALID_TRACKERS = new Set(['local', 'linear', 'github']);
+const VALID_CODEX_MODES = new Set(['shell', 'app-server']);
+
+export function loadWorkflow(workflowPath) {
+  if (!fs.existsSync(workflowPath)) {
+    throw new Error(`WORKFLOW file not found: ${workflowPath}`);
+  }
+
+  const raw = fs.readFileSync(workflowPath, 'utf8');
+  const { frontMatter, body } = parseFrontMatter(raw);
+  const config = frontMatter ? yaml.load(frontMatter) || {} : {};
+
+  if (!isPlainObject(config)) {
+    throw new Error('WORKFLOW front matter must be a YAML object');
+  }
+
+  return {
+    workflowPath,
+    config,
+    promptTemplate: (body || '').trim() || defaultPromptTemplate()
+  };
+}
+
+export function resolveRuntimeConfig(workflow, cliOptions = {}) {
+  const config = workflow.config || {};
+  const projectRoot = process.cwd();
+  const trackerKind = normalizeTrackerKind(config.tracker?.kind);
+
+  const workspaceRoot = normalizePath(
+    envOrValue(config.workspace?.root) || path.join(projectRoot, '.taskode', 'workspaces')
+  );
+
+  const logsRoot = normalizePath(
+    cliOptions.logsRoot || config.logs?.root || path.join(projectRoot, '.taskode', 'logs')
+  );
+
+  const runtime = {
+    projectRoot,
+    pollIntervalMs: requiredPositiveInteger(config.agent?.poll_interval_ms ?? 4000, 'agent.poll_interval_ms'),
+    maxConcurrentAgents: requiredPositiveInteger(
+      config.agent?.max_concurrent_agents ?? 2,
+      'agent.max_concurrent_agents'
+    ),
+    maxRetryAttempts: requiredPositiveInteger(config.agent?.max_retry_attempts ?? 5, 'agent.max_retry_attempts'),
+    maxRetryBackoffMs: requiredPositiveInteger(
+      config.agent?.max_retry_backoff_ms ?? 60_000,
+      'agent.max_retry_backoff_ms'
+    ),
+    maxConcurrentAgentsByState: normalizeStateLimits(config.agent?.max_concurrent_agents_by_state || {}),
+    workspaceRoot,
+    workspaceIgnoreNames: normalizeStringArray(config.workspace?.copy_ignore || DEFAULT_WORKSPACE_IGNORES),
+    seedWorkspaceFromProject: booleanOrDefault(config.workspace?.seed_from_project, true),
+    logsRoot,
+    tracker: {
+      kind: trackerKind,
+      apiKey: envOrValue(config.tracker?.api_key) || process.env.LINEAR_API_KEY || null,
+      projectSlug: config.tracker?.project_slug || null,
+      activeStates: normalizeStringArray(
+        config.tracker?.active_states || ['Todo', 'In Progress', 'Rework', 'Backlog', 'todo', 'in_progress']
+      ),
+      terminalStates: normalizeStringArray(
+        config.tracker?.terminal_states || ['Done', 'Closed', 'Cancelled', 'Duplicate', 'done', 'closed', 'cancelled', 'duplicate']
+      ),
+      githubToken: envOrValue(config.tracker?.github_token) || process.env.GITHUB_TOKEN || null,
+      githubOwner: normalizeOptionalString(config.tracker?.github_owner),
+      githubRepo: normalizeOptionalString(config.tracker?.github_repo),
+      githubLabels: normalizeStringArray(config.tracker?.github_labels || []),
+      githubBaseUrl: normalizeOptionalString(config.tracker?.github_base_url) || 'https://api.github.com'
+    },
+    worker: {
+      sshHosts: normalizeStringArray(config.worker?.ssh_hosts || []),
+      maxConcurrentAgentsPerHost: optionalPositiveInteger(
+        config.worker?.max_concurrent_agents_per_host,
+        'worker.max_concurrent_agents_per_host'
+      )
+    },
+    codex: {
+      command: requiredNonEmptyString(envOrValue(config.codex?.command) || 'echo "simulated codex run"', 'codex.command'),
+      timeoutMs: requiredPositiveInteger(config.codex?.timeout_ms ?? 120_000, 'codex.timeout_ms'),
+      mode: normalizeCodexMode(config.codex?.mode || 'shell'),
+      maxTurns: requiredPositiveInteger(config.agent?.max_turns ?? 20, 'agent.max_turns'),
+      approvalPolicy: normalizeApprovalPolicy(config.codex?.approval_policy),
+      threadSandbox: normalizeOptionalString(config.codex?.thread_sandbox) || 'workspace-write',
+      turnSandboxPolicy: normalizeOptionalObject(config.codex?.turn_sandbox_policy, 'codex.turn_sandbox_policy'),
+      turnTimeoutMs: requiredPositiveInteger(config.codex?.turn_timeout_ms ?? 3_600_000, 'codex.turn_timeout_ms'),
+      readTimeoutMs: requiredPositiveInteger(config.codex?.read_timeout_ms ?? 5_000, 'codex.read_timeout_ms'),
+      stallTimeoutMs: requiredNonNegativeInteger(config.codex?.stall_timeout_ms ?? 300_000, 'codex.stall_timeout_ms')
+    },
+    hooks: {
+      afterCreate: normalizeOptionalString(config.hooks?.after_create),
+      beforeRun: normalizeOptionalString(config.hooks?.before_run),
+      afterRun: normalizeOptionalString(config.hooks?.after_run),
+      beforeRemove: normalizeOptionalString(config.hooks?.before_remove),
+      afterRemove: normalizeOptionalString(config.hooks?.after_remove),
+      timeoutMs: requiredPositiveInteger(config.hooks?.timeout_ms ?? 60_000, 'hooks.timeout_ms')
+    },
+    review: {
+      autoCleanupApproved: booleanOrDefault(config.review?.auto_cleanup_approved, true)
+    },
+    server: {
+      host: normalizeOptionalString(config.server?.host) || '127.0.0.1',
+      port: requiredNonNegativeInteger(cliOptions.port ?? config.server?.port ?? 4317, 'server.port')
+    },
+    auth: {
+      token: normalizeOptionalString(envOrValue(config.auth?.token) || process.env.TASKODE_API_TOKEN || null)
+    },
+    observability: {
+      dashboardEnabled: booleanOrDefault(config.observability?.dashboard_enabled, true),
+      refreshMs: requiredPositiveInteger(config.observability?.refresh_ms ?? 1000, 'observability.refresh_ms'),
+      renderIntervalMs: requiredPositiveInteger(
+        config.observability?.render_interval_ms ?? 16,
+        'observability.render_interval_ms'
+      )
+    },
+    policy: {
+      allowCommands: normalizeStringArray(config.policy?.allow_commands || ['*']),
+      denyCommands: normalizeStringArray(config.policy?.deny_commands || [])
+    },
+    promptTemplate: workflow.promptTemplate,
+    workflowPath: workflow.workflowPath
+  };
+
+  validateTrackerConfig(runtime.tracker);
+  validateTurnSandboxPolicy(runtime.codex.turnSandboxPolicy, runtime.workspaceRoot);
+
+  return runtime;
+}
+
+export function resolveTurnSandboxPolicy(config, workspacePath, options = {}) {
+  if (config.codex.turnSandboxPolicy) {
+    return config.codex.turnSandboxPolicy;
+  }
+
+  const writableRoot = options.remote ? String(workspacePath) : normalizePath(workspacePath || config.workspaceRoot);
+  return {
+    type: 'workspaceWrite',
+    writableRoots: [writableRoot],
+    networkAccess: false
+  };
+}
+
+export function replaceConfigContents(target, source) {
+  for (const key of Object.keys(target)) {
+    delete target[key];
+  }
+  Object.assign(target, source);
+  return target;
+}
+
+function parseFrontMatter(text) {
+  if (!text.startsWith('---\n')) {
+    return { frontMatter: '', body: text };
+  }
+
+  const closing = text.indexOf('\n---\n', 4);
+  if (closing === -1) {
+    throw new Error('Invalid WORKFLOW front matter: missing closing ---');
+  }
+
+  return {
+    frontMatter: text.slice(4, closing),
+    body: text.slice(closing + 5)
+  };
+}
+
+function defaultPromptTemplate() {
+  return 'You are working on issue {{ issue.identifier }} - {{ issue.title }}\n\n{{ issue.description }}';
+}
+
+function normalizeTrackerKind(value) {
+  const trackerKind = String(value || 'local').trim().toLowerCase();
+  if (!VALID_TRACKERS.has(trackerKind)) {
+    throw new Error(`Unsupported tracker kind: ${trackerKind}`);
+  }
+  return trackerKind;
+}
+
+function normalizeCodexMode(value) {
+  const mode = String(value || 'shell').trim().toLowerCase();
+  if (!VALID_CODEX_MODES.has(mode)) {
+    throw new Error(`Unsupported codex mode: ${mode}`);
+  }
+  return mode;
+}
+
+function envOrValue(value) {
+  if (typeof value !== 'string') return value;
+  if (!value.startsWith('$')) return value;
+  return process.env[value.slice(1)] || null;
+}
+
+function normalizePath(value) {
+  if (!value) return value;
+  if (typeof value !== 'string') {
+    throw new Error(`Expected path string, received ${typeof value}`);
+  }
+  if (value.startsWith('~/')) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return path.resolve(value);
+}
+
+function validateTrackerConfig(tracker) {
+  if (tracker.kind === 'linear' && !tracker.projectSlug) {
+    throw new Error('tracker.project_slug is required for linear tracker');
+  }
+
+  if (tracker.kind === 'github' && (!tracker.githubOwner || !tracker.githubRepo)) {
+    throw new Error('tracker.github_owner and tracker.github_repo are required for github tracker');
+  }
+}
+
+function validateTurnSandboxPolicy(policy, workspaceRoot) {
+  if (!policy) return;
+  if (policy.type === 'workspaceWrite') {
+    const writableRoots = Array.isArray(policy.writableRoots) ? policy.writableRoots : [];
+    for (const root of writableRoots) {
+      if (typeof root !== 'string' || root.trim() === '') {
+        throw new Error('codex.turn_sandbox_policy.writableRoots entries must be non-empty strings');
+      }
+      if (!path.isAbsolute(root)) {
+        throw new Error(`codex.turn_sandbox_policy contains non-absolute writable root: ${root}`);
+      }
+      if (!normalizePath(root).startsWith(normalizePath(workspaceRoot))) {
+        throw new Error(`codex.turn_sandbox_policy root is outside workspace root: ${root}`);
+      }
+    }
+  }
+}
+
+function normalizeApprovalPolicy(value) {
+  if (value === undefined || value === null) {
+    return {
+      reject: {
+        sandbox_approval: true,
+        rules: true,
+        mcp_elicitations: true
+      }
+    };
+  }
+
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (isPlainObject(value)) {
+    return value;
+  }
+
+  throw new Error('codex.approval_policy must be a string or object');
+}
+
+function normalizeStateLimits(value) {
+  if (!isPlainObject(value)) {
+    throw new Error('agent.max_concurrent_agents_by_state must be an object');
+  }
+
+  const normalized = {};
+  for (const [stateName, limit] of Object.entries(value)) {
+    normalized[String(stateName).trim().toLowerCase()] = requiredPositiveInteger(
+      limit,
+      `agent.max_concurrent_agents_by_state.${stateName}`
+    );
+  }
+  return normalized;
+}
+
+function normalizeOptionalObject(value, field) {
+  if (value === undefined || value === null) return null;
+  if (!isPlainObject(value)) {
+    throw new Error(`${field} must be an object`);
+  }
+  return value;
+}
+
+function normalizeOptionalString(value) {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string') {
+    throw new Error(`Expected string value, received ${typeof value}`);
+  }
+  const trimmed = value.trim();
+  return trimmed === '' ? null : trimmed;
+}
+
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    throw new Error('Expected an array of strings');
+  }
+
+  return [...new Set(value.map((entry) => String(entry || '').trim()).filter(Boolean))];
+}
+
+function requiredNonEmptyString(value, field) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function requiredPositiveInteger(value, field) {
+  const number = Number(value);
+  if (!Number.isInteger(number) || number <= 0) {
+    throw new Error(`${field} must be a positive integer`);
+  }
+  return number;
+}
+
+function requiredNonNegativeInteger(value, field) {
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < 0) {
+    throw new Error(`${field} must be a non-negative integer`);
+  }
+  return number;
+}
+
+function optionalPositiveInteger(value, field) {
+  if (value === undefined || value === null || value === '') {
+    return null;
+  }
+  return requiredPositiveInteger(value, field);
+}
+
+function booleanOrDefault(value, fallback) {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value !== 'boolean') {
+    throw new Error(`Expected boolean value, received ${typeof value}`);
+  }
+  return value;
+}
+
+function isPlainObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}

package/src/workspace.js

@@ -0,0 +1,291 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { exec, spawn } from 'node:child_process';
+import { assertPathInsideRoot, assertRemotePathSafe, canonicalizePath } from './path-safety.js';
+import { runSSHCommand, shellEscape, startSSHProcess } from './ssh.js';
+
+const REMOTE_WORKSPACE_MARKER = '__TASKODE_WORKSPACE__';
+
+export class WorkspaceManager {
+  constructor({ config, store }) {
+    this.config = config;
+    this.store = store;
+    fs.mkdirSync(canonicalizePath(config.workspaceRoot), { recursive: true });
+  }
+
+  async ensure(issue, workerHost = null) {
+    const workspaceKey = sanitize(issue.identifier || issue.id);
+    const workspacePath = buildWorkspacePath(this.config.workspaceRoot, workspaceKey, workerHost);
+    const createdNow = workerHost
+      ? await ensureRemoteWorkspace(workerHost, workspacePath, this.config.hooks.timeoutMs)
+      : ensureLocalWorkspace(this.config.workspaceRoot, workspacePath);
+
+    if (createdNow && this.config.seedWorkspaceFromProject) {
+      if (workerHost) {
+        await syncProjectSnapshotToRemote({
+          projectRoot: this.config.projectRoot,
+          workspacePath,
+          workerHost,
+          ignoreNames: new Set(this.config.workspaceIgnoreNames || [])
+        });
+      } else {
+        copyProjectSnapshot(this.config.projectRoot, workspacePath, new Set(this.config.workspaceIgnoreNames || []));
+      }
+    }
+
+    if (createdNow && this.config.hooks.afterCreate) {
+      await runHook({
+        command: this.config.hooks.afterCreate,
+        cwd: workspacePath,
+        issue,
+        workerHost,
+        timeoutMs: this.config.hooks.timeoutMs
+      });
+    }
+
+    return {
+      path: workspacePath,
+      workspace_key: workspaceKey,
+      worker_host: workerHost,
+      created_now: createdNow
+    };
+  }
+
+  async runBeforeRunHook(workspacePath, issue, workerHost = null) {
+    if (!this.config.hooks.beforeRun) return;
+    await runHook({
+      command: this.config.hooks.beforeRun,
+      cwd: workspacePath,
+      issue,
+      workerHost,
+      timeoutMs: this.config.hooks.timeoutMs
+    });
+  }
+
+  async runAfterRunHook(workspacePath, issue, workerHost = null) {
+    if (!this.config.hooks.afterRun) return;
+
+    try {
+      await runHook({
+        command: this.config.hooks.afterRun,
+        cwd: workspacePath,
+        issue,
+        workerHost,
+        timeoutMs: this.config.hooks.timeoutMs
+      });
+    } catch (error) {
+      this.store.appendSystemLog(`after_run hook failed: ${error.message}`);
+    }
+  }
+
+  async cleanup(issue) {
+    const workerHost = issue.workerHost || null;
+    const workspaceKey = issue.workspaceKey || sanitize(issue.identifier || issue.id);
+    return this.cleanupByPath(buildWorkspacePath(this.config.workspaceRoot, workspaceKey, workerHost), workerHost);
+  }
+
+  async cleanupByPath(workspacePath, workerHost = null) {
+    if (!workspacePath) return false;
+
+    if (workerHost) {
+      const safeRemotePath = assertRemotePathSafe(workspacePath);
+      await runBeforeRemoveHook(this.config, safeRemotePath, workerHost);
+      await removeRemoteWorkspace(workerHost, safeRemotePath, this.config.hooks.timeoutMs);
+      await runAfterRemoveHook(this.config, this.config.workspaceRoot, workerHost);
+      this.store.appendSystemLog(`workspace cleaned: ${safeRemotePath}`);
+      return true;
+    }
+
+    if (!fs.existsSync(workspacePath)) return false;
+
+    const safePath = assertPathInsideRoot(workspacePath, this.config.workspaceRoot);
+    await runBeforeRemoveHook(this.config, safePath, null);
+    fs.rmSync(safePath, { recursive: true, force: true });
+    await runAfterRemoveHook(this.config, this.config.workspaceRoot, null);
+    this.store.appendSystemLog(`workspace cleaned: ${safePath}`);
+    return true;
+  }
+
+  async cleanupIssueWorkspaces(identifier, workerHost = null) {
+    if (!identifier) return;
+
+    if (workerHost) {
+      await this.cleanupByPath(buildWorkspacePath(this.config.workspaceRoot, sanitize(identifier), workerHost), workerHost);
+      return;
+    }
+
+    await this.cleanupByPath(buildWorkspacePath(this.config.workspaceRoot, sanitize(identifier), null), null);
+    for (const host of this.config.worker?.sshHosts || []) {
+      await this.cleanupByPath(buildWorkspacePath(this.config.workspaceRoot, sanitize(identifier), host), host);
+    }
+  }
+}
+
+function ensureLocalWorkspace(workspaceRoot, workspacePath) {
+  const safePath = assertPathInsideRoot(workspacePath, workspaceRoot);
+  const createdNow = !fs.existsSync(safePath);
+  fs.mkdirSync(safePath, { recursive: true });
+  return createdNow;
+}
+
+async function ensureRemoteWorkspace(workerHost, workspacePath, timeoutMs) {
+  const safeRemotePath = assertRemotePathSafe(workspacePath);
+  const script = [
+    'set -eu',
+    `workspace=${shellEscape(safeRemotePath)}`,
+    'if [ -d "$workspace" ]; then',
+    '  created=0',
+    'elif [ -e "$workspace" ]; then',
+    '  rm -rf "$workspace"',
+    '  mkdir -p "$workspace"',
+    '  created=1',
+    'else',
+    '  mkdir -p "$workspace"',
+    '  created=1',
+    'fi',
+    'cd "$workspace"',
+    `printf '%s\\t%s\\t%s\\n' '${REMOTE_WORKSPACE_MARKER}' "$created" "$(pwd -P)"`
+  ].join('\n');
+
+  const { stdout } = await runSSHCommand(workerHost, script, { timeoutMs });
+  const line = stdout.split('\n').find((entry) => entry.startsWith(`${REMOTE_WORKSPACE_MARKER}\t`));
+  if (!line) {
+    throw new Error(`Remote workspace create did not return marker for ${workerHost}`);
+  }
+
+  const [, createdValue] = line.split('\t');
+  return createdValue === '1';
+}
+
+async function syncProjectSnapshotToRemote({ projectRoot, workspacePath, workerHost, ignoreNames }) {
+  const tarArgs = ['-C', projectRoot];
+  for (const ignoreName of ignoreNames) {
+    tarArgs.push('--exclude', ignoreName);
+  }
+  tarArgs.push('-cf', '-', '.');
+
+  const tarChild = spawn('tar', tarArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+  const sshChild = startSSHProcess(
+    workerHost,
+    `mkdir -p ${shellEscape(workspacePath)} && tar -xf - -C ${shellEscape(workspacePath)}`,
+    { stdio: ['pipe', 'pipe', 'pipe'] }
+  );
+
+  const tarErrors = [];
+  const sshErrors = [];
+  tarChild.stderr.on('data', (chunk) => tarErrors.push(String(chunk)));
+  sshChild.stderr.on('data', (chunk) => sshErrors.push(String(chunk)));
+  tarChild.stdout.pipe(sshChild.stdin);
+
+  const [tarStatus, sshStatus] = await Promise.all([
+    waitForExit(tarChild),
+    waitForExit(sshChild)
+  ]);
+
+  if (tarStatus !== 0 || sshStatus !== 0) {
+    throw new Error(
+      `Remote workspace sync failed: tar=${tarStatus} ssh=${sshStatus} ${tarErrors.join('').trim()} ${sshErrors.join('').trim()}`.trim()
+    );
+  }
+}
+
+async function removeRemoteWorkspace(workerHost, workspacePath, timeoutMs) {
+  await runSSHCommand(workerHost, `rm -rf ${shellEscape(workspacePath)}`, { timeoutMs });
+}
+
+async function runBeforeRemoveHook(config, workspacePath, workerHost) {
+  if (!config.hooks.beforeRemove) return;
+  await runHook({
+    command: config.hooks.beforeRemove,
+    cwd: workspacePath,
+    issue: null,
+    workerHost,
+    timeoutMs: config.hooks.timeoutMs
+  });
+}
+
+async function runAfterRemoveHook(config, workspaceRoot, workerHost) {
+  if (!config.hooks.afterRemove) return;
+  await runHook({
+    command: config.hooks.afterRemove,
+    cwd: workspaceRoot,
+    issue: null,
+    workerHost,
+    timeoutMs: config.hooks.timeoutMs
+  });
+}
+
+function copyProjectSnapshot(sourceRoot, targetRoot, ignoreNames) {
+  for (const entry of fs.readdirSync(sourceRoot, { withFileTypes: true })) {
+    if (ignoreNames.has(entry.name)) continue;
+
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const targetPath = path.join(targetRoot, entry.name);
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(targetPath, { recursive: true });
+      copyProjectSnapshot(sourcePath, targetPath, ignoreNames);
+      continue;
+    }
+
+    if (entry.isSymbolicLink()) {
+      fs.symlinkSync(fs.readlinkSync(sourcePath), targetPath);
+      continue;
+    }
+
+    fs.copyFileSync(sourcePath, targetPath);
+  }
+}
+
+function buildWorkspacePath(workspaceRoot, workspaceKey, workerHost) {
+  if (workerHost) {
+    return path.posix.join(workspaceRoot, workspaceKey);
+  }
+  return path.join(workspaceRoot, workspaceKey);
+}
+
+function sanitize(value) {
+  return String(value).replace(/[^a-zA-Z0-9._-]/g, '_');
+}
+
+function runHook({ command, cwd, issue, workerHost, timeoutMs }) {
+  return workerHost
+    ? runRemoteHook({ command, cwd, issue, workerHost, timeoutMs })
+    : runLocalHook({ command, cwd, issue, timeoutMs });
+}
+
+function runLocalHook({ command, cwd, issue, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    exec(command, { cwd, shell: '/bin/bash', timeout: timeoutMs, env: hookEnv(issue) }, (error) => {
+      if (error) return reject(error);
+      return resolve();
+    });
+  });
+}
+
+async function runRemoteHook({ command, cwd, issue, workerHost, timeoutMs }) {
+  const envExports = Object.entries(hookEnv(issue))
+    .filter(([key]) => key.startsWith('TASKODE_'))
+    .map(([key, value]) => `export ${key}=${shellEscape(value)}`)
+    .join('\n');
+
+  const script = [envExports, `cd ${shellEscape(cwd)}`, command].filter(Boolean).join('\n');
+  await runSSHCommand(workerHost, script, { timeoutMs });
+}
+
+function hookEnv(issue) {
+  const env = { ...process.env };
+  if (!issue) return env;
+  env.TASKODE_ISSUE_ID = String(issue.id || '');
+  env.TASKODE_ISSUE_IDENTIFIER = String(issue.identifier || issue.id || '');
+  env.TASKODE_ISSUE_TITLE = String(issue.title || '');
+  env.TASKODE_ISSUE_STATE = String(issue.state || '');
+  return env;
+}
+
+function waitForExit(child) {
+  return new Promise((resolve, reject) => {
+    child.on('error', reject);
+    child.on('close', (code) => resolve(code ?? 0));
+  });
+}