@profoundlogic/coderflow-cli 0.13.10 → 0.13.11-dev.20260807233136.g074f26b1

package/README.md

@@ -90,6 +90,38 @@ visibility.
 When supplying a container ID directly, use the full ID or an unambiguous
 prefix of at least 12 hexadecimal characters.
 
+## Exporting and Importing Tasks
+
+Export a task as a portable ZIP package:
+
+```bash
+coder export <task-id>
+coder export <task-id> --output ./task-backup.zip
+```
+
+The package contains persisted task output and activity history, task metadata,
+container logs, and a `/workspace` snapshot when the retained container is
+available. Runtime-only server credential configuration is not included.
+
+Import an export package or a plain local workspace directory:
+
+```bash
+# Restore a ready-to-use staged container (default)
+coder import ./task-backup.zip
+
+# Package a directory and restore it into an environment
+coder import ./my-workspace --environment=myproject
+
+# Store the package as a reusable objective, or launch immediately
+coder import ./task-backup.zip --mode=objective
+coder import ./task-backup.zip --mode=running
+```
+
+Import modes are `objective`, `staged` (the default), and `running`. Use
+`--environment`, `--name`, `--agent`, or `--instructions` to override package
+metadata. In the Web UI, **Import** creates an objective from the Objectives
+view and a staged task from the Tasks or Board view.
+
 ## Configuration and Profiles
 
 Manage connection settings:

package/coder.js

@@ -20,6 +20,8 @@ import { attachToContainer } from './lib/commands/attach.js';
 import { handleConfig } from './lib/commands/config.js';
 import { handleProfile } from './lib/commands/profile.js';
 import { runTest } from './lib/commands/test.js';
+import { exportTask } from './lib/commands/export.js';
+import { importTask } from './lib/commands/import.js';
 import { setCliProfileOverride } from './lib/config.js';
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -167,6 +169,14 @@ async function main() {
         await runTest(args.slice(1));
         break;
 
+      case 'export':
+        await exportTask(args.slice(1));
+        break;
+
+      case 'import':
+        await importTask(args.slice(1));
+        break;
+
       case 'start':
         await startInteractive(args.slice(1));
         break;

package/lib/commands/export.js

@@ -0,0 +1,78 @@
+/**
+ * Command: coder export - Download a portable task package.
+ */
+
+import { createWriteStream, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { getApiKey, getServerUrl } from '../config.js';
+import { buildHttpError } from '../http-client.js';
+
+function parseExportArgs(args) {
+  let taskId = null;
+  let output = null;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--output' || arg === '-o') {
+      output = args[++index];
+    } else if (arg.startsWith('--output=')) {
+      output = arg.slice('--output='.length);
+    } else if (!arg.startsWith('-') && !taskId) {
+      taskId = arg;
+    } else {
+      throw new Error(`Unexpected export argument: ${arg}`);
+    }
+  }
+
+  if (!taskId) throw new Error('Task ID required. Usage: coder export <task-id> [--output <file.zip>]');
+  return { taskId, output };
+}
+
+function getResponseFilename(response, taskId) {
+  const disposition = response.headers.get('content-disposition') || '';
+  const match = disposition.match(/filename="([^"]+)"/i);
+  return match?.[1] || `coderflow-task-${taskId}.zip`;
+}
+
+export async function writeExportStream(source, destination) {
+  const directory = path.dirname(destination);
+  const temporaryPath = path.join(
+    directory,
+    `.coderflow-export-${process.pid}-${randomUUID()}.tmp`
+  );
+
+  try {
+    await pipeline(source, createWriteStream(temporaryPath, { flags: 'wx' }));
+    // Publishing with a hard link is atomic and fails with EEXIST instead of
+    // replacing a destination another process (or the user) already owns.
+    await fs.link(temporaryPath, destination);
+  } finally {
+    await fs.rm(temporaryPath, { force: true }).catch(() => {});
+  }
+}
+
+export async function exportTask(args = []) {
+  const { taskId, output } = parseExportArgs(args);
+  const serverUrl = await getServerUrl();
+  const apiKey = await getApiKey();
+  const response = await fetch(`${serverUrl}/tasks/${encodeURIComponent(taskId)}/export`, {
+    headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+  });
+
+  if (!response.ok) {
+    const contentType = response.headers.get('content-type') || '';
+    const body = contentType.includes('application/json')
+      ? await response.json()
+      : await response.text();
+    throw buildHttpError(response.status, body);
+  }
+
+  const destination = path.resolve(output || getResponseFilename(response, taskId));
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await writeExportStream(Readable.fromWeb(response.body), destination);
+  console.log(`Task ${taskId} exported to ${destination}`);
+  return destination;
+}

package/lib/commands/import.js

@@ -0,0 +1,115 @@
+/**
+ * Command: coder import - Import a task export or local workspace directory.
+ */
+
+import { createWriteStream, openAsBlob, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ZipArchive } from 'archiver';
+import { getApiKey, getServerUrl } from '../config.js';
+import { buildHttpError } from '../http-client.js';
+
+function takeOption(args, index, name) {
+  const arg = args[index];
+  if (arg === `--${name}`) {
+    if (!args[index + 1]) throw new Error(`--${name} requires a value`);
+    return { value: args[index + 1], consumed: 2 };
+  }
+  if (arg.startsWith(`--${name}=`)) {
+    return { value: arg.slice(name.length + 3), consumed: 1 };
+  }
+  return null;
+}
+
+export function parseImportArgs(args) {
+  let source = null;
+  const options = { mode: 'staged' };
+  const names = ['mode', 'environment', 'name', 'agent', 'instructions'];
+
+  for (let index = 0; index < args.length;) {
+    const arg = args[index];
+    let matched = false;
+    for (const name of names) {
+      const parsed = takeOption(args, index, name);
+      if (!parsed) continue;
+      options[name] = parsed.value;
+      index += parsed.consumed;
+      matched = true;
+      break;
+    }
+    if (matched) continue;
+    if (!arg.startsWith('-') && !source) {
+      source = arg;
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unexpected import argument: ${arg}`);
+  }
+
+  if (!source) throw new Error('Path required. Usage: coder import <directory-or-zip> [options]');
+  if (!['objective', 'staged', 'running'].includes(options.mode)) {
+    throw new Error('--mode must be objective, staged, or running');
+  }
+  return { source, options };
+}
+
+async function zipDirectory(sourceDir) {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'coderflow-cli-import-'));
+  const zipPath = path.join(tempDir, 'workspace.zip');
+  await new Promise((resolve, reject) => {
+    const output = createWriteStream(zipPath, { flags: 'wx' });
+    const archive = new ZipArchive({ zlib: { level: 6 } });
+    output.on('close', resolve);
+    output.on('error', reject);
+    archive.on('error', reject);
+    archive.pipe(output);
+    archive.directory(sourceDir, false);
+    archive.finalize().catch(reject);
+  });
+  return { zipPath, tempDir };
+}
+
+export async function importTask(args = []) {
+  const { source, options } = parseImportArgs(args);
+  const sourcePath = path.resolve(source);
+  const sourceStats = await fs.stat(sourcePath).catch(() => null);
+  if (!sourceStats) throw new Error(`Import path does not exist: ${sourcePath}`);
+
+  let archivePath = sourcePath;
+  let tempDir = null;
+  if (sourceStats.isDirectory()) {
+    console.log(`Packaging workspace directory ${sourcePath}...`);
+    ({ zipPath: archivePath, tempDir } = await zipDirectory(sourcePath));
+  } else if (path.extname(sourcePath).toLowerCase() !== '.zip') {
+    throw new Error('Import path must be a directory or .zip file');
+  }
+
+  try {
+    const form = new FormData();
+    form.append('archive', await openAsBlob(archivePath, { type: 'application/zip' }), path.basename(archivePath));
+    for (const [key, value] of Object.entries(options)) {
+      if (value != null && value !== '') form.append(key, value);
+    }
+
+    const serverUrl = await getServerUrl();
+    const apiKey = await getApiKey();
+    const response = await fetch(`${serverUrl}/tasks/import`, {
+      method: 'POST',
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      body: form
+    });
+    const contentType = response.headers.get('content-type') || '';
+    const data = contentType.includes('application/json')
+      ? await response.json()
+      : await response.text();
+    if (!response.ok) throw buildHttpError(response.status, data);
+
+    console.log(`Task import created ${data.status} ${data.taskId}`);
+    if (data.containerId) console.log(`Container: ${data.containerId}`);
+    if (data.queuePosition) console.log(`Queue position: ${data.queuePosition}`);
+    console.log(`Environment: ${data.environment}`);
+    return data;
+  } finally {
+    if (tempDir) await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}

package/lib/help.js

@@ -182,6 +182,46 @@ Examples:
   coder logs 1759542727986-3uoyf48lr --tail=100
 `,
 
+  export: `
+Usage: coder export <task-id> [options]
+
+Download a portable task package containing task output, logs, metadata, and
+the retained container workspace when it is available.
+
+Arguments:
+  task-id               Task ID to export (required)
+
+Options:
+  --output, -o <file>   Destination zip path (defaults to the server filename)
+
+Examples:
+  coder export 1759542727986-3uoyf48lr
+  coder export 1759542727986-3uoyf48lr --output ./task-backup.zip
+`,
+
+  import: `
+Usage: coder import <directory-or-zip> [options]
+
+Create a new objective or task from a CoderFlow export package or a plain
+workspace directory. Plain directories are packaged before upload.
+
+Arguments:
+  directory-or-zip      Export zip or local workspace directory (required)
+
+Options:
+  --mode=<mode>         objective, staged, or running (default: staged)
+  --environment=<name>  Override/select the destination environment
+  --name=<name>         Override the imported task name
+  --agent=<agent>       Override the imported/default agent
+  --instructions=<text> Override instructions used when the task runs
+
+Examples:
+  coder import ./task-backup.zip
+  coder import ./workspace --environment=hello --mode=staged
+  coder import ./task-backup.zip --mode=objective
+  coder import ./task-backup.zip --mode=running --agent=codex
+`,
+
   list: `
 Usage: coder list [options]
 
@@ -327,6 +367,8 @@ Commands:
   coder apply [task-id]                              Apply patches from completed task to local repos
   coder discard [--env=<environment>] [--yes]        Discard applied changes from repos
   coder attach [container-or-task-id] [options]      Connect to a running container
+  coder export <task-id> [--output=<file.zip>]       Export task contents and logs
+  coder import <directory-or-zip> [options]          Import an objective or task container
 
 Setup:
   coder login [--sso]                                Authenticate with server
@@ -389,6 +431,8 @@ Task Management:
   coder logs <task-id> [--tail=N]                    Show task logs
   coder list [--status=...] [--environment=...]      List tasks with optional filters
   coder reject <task-id> [--cleanup]                 Reject task results
+  coder export <task-id> [--output=file.zip]         Export task contents and logs
+  coder import <directory-or-zip> [options]          Restore an objective or task
 
 Interactive Sessions:
   coder start <environment> [options]                Start interactive session with AI agent
@@ -445,6 +489,8 @@ Task Management (Web UI alternative):
   coder status 1759542727986-3uoyf48lr               # Check task status
   coder results 1759542727986-3uoyf48lr              # Get task results
   coder list --status=completed                      # List completed tasks
+  coder export 1759542727986-3uoyf48lr               # Download a portable task package
+  coder import ./task-export.zip --mode=staged       # Restore into a staged container
 
 Interactive Sessions (Web UI alternative):
   coder start hello                                  # Start AI agent in environment

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profoundlogic/coderflow-cli",
-  "version": "0.13.10",
+  "version": "0.13.11-dev.20260807233136.g074f26b1",
   "description": "AI Coder CLI - Command-line interface for managing AI coding tasks",
   "main": "coder.js",
   "type": "module",
@@ -28,8 +28,9 @@
   "license": "SEE LICENSE IN LICENSE.txt",
   "homepage": "https://coderflow.ai",
   "dependencies": {
-    "ws": "^8.21.1",
     "@inquirer/prompts": "^8.5.2",
-    "open": "^11.0.0"
+    "archiver": "^8.0.0",
+    "open": "^11.0.0",
+    "ws": "^8.21.1"
   }
 }