@oxgeneral/orch 0.3.2 → 0.3.4

package/dist/claude-INM52PTH.js

@@ -0,0 +1,88 @@
+import { createStreamingEvents, extractTokens } from './chunk-S3QYSBW4.js';
+import './chunk-XDVMX2FO.js';
+import { classifyAdapterError } from './chunk-NLQAJ7TW.js';
+import './chunk-O2MSGW3V.js';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+var execFileAsync = promisify(execFile);
+var ClaudeAdapter = class {
+  constructor(processManager) {
+    this.processManager = processManager;
+  }
+  kind = "claude";
+  async test() {
+    try {
+      const { stdout } = await execFileAsync("claude", ["--version"]);
+      return { ok: true, version: stdout.trim() };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        error: "Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code",
+        errorKind: classifyAdapterError(msg)
+      };
+    }
+  }
+  execute(params) {
+    const args = [
+      "--print",
+      "--output-format",
+      "stream-json",
+      "--max-turns",
+      String(params.config.max_turns ?? 50),
+      "--verbose",
+      "--dangerously-skip-permissions"
+      // Agents run autonomously; stdin is 'ignore' so prompts would hang
+    ];
+    if (params.config.model) {
+      args.push("--model", params.config.model);
+    }
+    if (params.config.system_prompt) {
+      args.push("--system-prompt", params.config.system_prompt);
+    }
+    args.push(params.prompt);
+    const { process: proc, pid } = this.processManager.spawn("claude", args, {
+      cwd: params.workspace,
+      env: { ...process.env, ...params.env },
+      signal: params.signal
+    });
+    const events = createStreamingEvents(proc, parseClaudeEvent, "Claude", params.signal);
+    return { pid, events };
+  }
+  async stop(pid) {
+    await this.processManager.killWithGrace(pid);
+  }
+};
+function parseClaudeEvent(line) {
+  if (!line.trim()) return null;
+  try {
+    const parsed = JSON.parse(line);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    switch (parsed.type) {
+      case "assistant":
+        return { type: "output", timestamp, data: parsed.message ?? parsed };
+      case "tool_use":
+        return { type: "tool_call", timestamp, data: parsed };
+      case "tool_result":
+        return { type: "output", timestamp, data: parsed };
+      case "error": {
+        const errData = parsed.error ?? parsed;
+        const errMsg = typeof errData === "string" ? errData : JSON.stringify(errData);
+        return { type: "error", timestamp, data: errData, errorKind: classifyAdapterError(errMsg) };
+      }
+      case "result": {
+        const tokens = extractTokens(parsed, { statsFallback: true });
+        return { type: "done", timestamp, data: parsed, tokens };
+      }
+      default:
+        return { type: "output", timestamp, data: parsed };
+    }
+  } catch {
+    return { type: "output", timestamp: (/* @__PURE__ */ new Date()).toISOString(), data: line };
+  }
+}
+
+export { ClaudeAdapter };
+//# sourceMappingURL=claude-INM52PTH.js.map
+//# sourceMappingURL=claude-INM52PTH.js.map

package/dist/claude-INM52PTH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/infrastructure/adapters/claude.ts"],"names":[],"mappings":"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","file":"claude-INM52PTH.js","sourcesContent":["/**\n * Claude Code adapter.\n *\n * Spawns `claude --print --output-format stream-json` in headless mode.\n * Parses JSON-lines from stdout into AgentEvent stream.\n */\n\nimport type { IAgentAdapter, AdapterTestResult, ExecuteParams, AgentEvent, ExecuteHandle } from './interface.js';\nimport type { IProcessManager } from '../process/process-manager.js';\nimport { extractTokens, createStreamingEvents } from './utils.js';\nimport { classifyAdapterError, AdapterErrorKind } from '../../domain/errors.js';\nimport { execFile } from 'node:child_process';\nimport { promisify } from 'node:util';\n\nconst execFileAsync = promisify(execFile);\n\nexport class ClaudeAdapter implements IAgentAdapter {\n  readonly kind = 'claude';\n\n  constructor(private readonly processManager: IProcessManager) {}\n\n  async test(): Promise<AdapterTestResult> {\n    try {\n      const { stdout } = await execFileAsync('claude', ['--version']);\n      return { ok: true, version: stdout.trim() };\n    } catch (err) {\n      const msg = err instanceof Error ? err.message : String(err);\n      return {\n        ok: false,\n        error: 'Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code',\n        errorKind: classifyAdapterError(msg),\n      };\n    }\n  }\n\n  execute(params: ExecuteParams): ExecuteHandle {\n    const args = [\n      '--print',\n      '--output-format', 'stream-json',\n      '--max-turns', String(params.config.max_turns ?? 50),\n      '--verbose',\n      '--dangerously-skip-permissions', // Agents run autonomously; stdin is 'ignore' so prompts would hang\n    ];\n\n    if (params.config.model) {\n      args.push('--model', params.config.model);\n    }\n\n    if (params.config.system_prompt) {\n      args.push('--system-prompt', params.config.system_prompt);\n    }\n\n    args.push(params.prompt);\n\n    const { process: proc, pid } = this.processManager.spawn('claude', args, {\n      cwd: params.workspace,\n      env: { ...process.env, ...params.env },\n      signal: params.signal,\n    });\n\n    const events = createStreamingEvents(proc, parseClaudeEvent, 'Claude', params.signal);\n\n    return { pid, events };\n  }\n\n  async stop(pid: number): Promise<void> {\n    await this.processManager.killWithGrace(pid);\n  }\n}\n\nfunction parseClaudeEvent(line: string): AgentEvent | null {\n  if (!line.trim()) return null;\n\n  try {\n    const parsed: Record<string, unknown> = JSON.parse(line);\n    const timestamp = new Date().toISOString();\n\n    switch (parsed.type) {\n      case 'assistant':\n        return { type: 'output', timestamp, data: (parsed.message as unknown) ?? parsed };\n      case 'tool_use':\n        return { type: 'tool_call', timestamp, data: parsed };\n      case 'tool_result':\n        return { type: 'output', timestamp, data: parsed };\n      case 'error': {\n        const errData = (parsed.error as unknown) ?? parsed;\n        const errMsg = typeof errData === 'string' ? errData : JSON.stringify(errData);\n        return { type: 'error', timestamp, data: errData, errorKind: classifyAdapterError(errMsg) };\n      }\n      case 'result': {\n        const tokens = extractTokens(parsed, { statsFallback: true });\n        return { type: 'done', timestamp, data: parsed, tokens };\n      }\n      default:\n        return { type: 'output', timestamp, data: parsed };\n    }\n  } catch {\n    return { type: 'output', timestamp: new Date().toISOString(), data: line };\n  }\n}\n"]}

package/dist/claude-NHUNA5RZ.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+export { ClaudeAdapter } from './chunk-D6RFF3KN.js';
+import './chunk-W6RSVMXR.js';
+import './chunk-CHIP7O6V.js';
+import './chunk-2C2TFQ7K.js';

package/dist/cli.js

@@ -1,2 +1,200 @@
 #!/usr/bin/env node
-import {a as a$1,b,i}from'./chunk-L26TK7Y5.js';import {o}from'./chunk-ZA5Z33GO.js';import {a as a$2,b as b$1}from'./chunk-GZ2Q56YZ.js';import {Command}from'commander';function h(o$1){let t=o$1.noColor||"NO_COLOR"in process.env||false,e=o$1.ascii||process.env.TERM==="dumb"||false;return {projectRoot:o(),json:o$1.json??false,quiet:o$1.quiet??false,noColor:t,ascii:e}}var p={task:async(o,t)=>{(await import('./task-J6ZN7ALI.js')).registerTaskCommand(o,t);},agent:async(o,t)=>{(await import('./agent-S4DKSX63.js')).registerAgentCommand(o,t);},status:async(o,t)=>{(await import('./status-DLBNWSWM.js')).registerStatusCommand(o,t);},logs:async(o,t)=>{(await import('./logs-5QHJWMEG.js')).registerLogsCommand(o,t);},config:async(o,t)=>{(await import('./config-CCSS2P7R.js')).registerConfigCommand(o,t);},context:async(o,t)=>{(await import('./context-GSMQHQES.js')).registerContextCommand(o,t);},msg:async(o,t)=>{(await import('./msg-4SCLBO4K.js')).registerMsgCommand(o,t);},goal:async(o,t)=>{(await import('./goal-RFKFPR7M.js')).registerGoalCommand(o,t);},team:async(o,t)=>{(await import('./team-MSIBKOQC.js')).registerTeamCommand(o,t);}},c={run:async(o,t)=>{(await import('./run-HSHRELOP.js')).registerRunCommand(o,t);},doctor:async(o,t)=>{(await import('./doctor-KBK5JZBZ.js')).registerDoctorCommand(o,t);},tui:async(o,t)=>{(await import('./tui-LW7WIDE3.js')).registerTuiCommand(o,t);}},a=new Command;a.name("orchestry").description("Agents Organizations \u2014 CLI orchestrator for AI agents").version("0.3.2").option("--json","Output as JSON").option("--quiet","Minimal output (IDs only)").option("--no-color","Disable colors").option("--ascii","ASCII-only output (no Unicode)").hook("preAction",async o=>{let t=o.opts();t.ascii&&a$1(true),t.color===false&&b(true);});var y=[["task","Manage tasks"],["agent","Manage agents"],["status","Show orchestrator status"],["logs","View run logs"],["config","Manage configuration"],["context","Shared context store for inter-agent data exchange"],["msg","Inter-agent messaging"],["goal","Manage goals"],["team","Manage teams"],["run","Run tasks"],["doctor","Check adapters and dependencies"],["tui","Launch TUI dashboard"],["init","Initialize project"],["update","Check for updates"]],j=new Set(y.map(([o])=>o));async function L(){a.parseOptions(process.argv);let o=a.opts(),t=h({json:o.json,quiet:o.quiet,noColor:o.color===false,ascii:o.ascii}),e=process.argv.slice(2).find(n=>!n.startsWith("-")),v=e!==void 0&&j.has(e);if((process.argv.includes("--help")||process.argv.includes("-h")||process.argv.includes("--version")||process.argv.includes("-V"))&&!v){for(let[n,i]of y)a.command(n).description(i);await a.parseAsync(process.argv);return}if(e==="init"){let{registerInitCommand:n}=await import('./init-WRDFAFS2.js');n(a);}else if(e==="update"){let{registerUpdateCommand:n}=await import('./update-PC2ENCKU.js');n(a);}let O=!e||e in c,{buildFullContainer:d,buildLightContainer:b}=await import('./container-OIXLFSX2.js');try{if(O){let n=await d(t),i=e?c[e]:void 0;i?await i(a,n):await Promise.all(Object.values(c).map(x=>x(a,n)));let s=e?p[e]:void 0;s&&await s(a,n);}else {let n=await b(t),i=p[e];i?await i(a,n):await Promise.all(Object.values(p).map(s=>s(a,n)));}}catch(n){if(n instanceof b$1){if(e==="doctor"){let{registerDoctorCommand:i}=await import('./doctor-KBK5JZBZ.js');i(a);}if(process.argv.length<=2){let{runInit:i}=await import('./init-WRDFAFS2.js');await i();let s=await d(t);await c.tui(a,s),await a.parseAsync([...process.argv,"tui"]);return}if(e==="init"||e==="doctor"||e==="update"){await a.parseAsync(process.argv);return}i(n.message,n.hint),process.exit(n.exitCode);}throw n}process.argv.length<=2&&process.argv.push("tui");let m,g=e==="tui"||e==="update",M=g?Promise.resolve(null):import('./update-check-HGMBDYHL.js').then(n=>(m=n,n.checkForUpdateSWR(a.version()??"0.0.0")));if(await a.parseAsync(process.argv),!g){let n=await M;n&&m&&m.printUpdateNotification(n);}}L().catch(o=>{o instanceof a$2&&(i(o.message,o.hint),process.exit(o.exitCode)),i(o instanceof Error?o.message:String(o)),process.env.ORCHESTRY_DEBUG&&console.error(o),process.exit(1);});
+import { setAsciiMode, setNoColor, printError } from './chunk-7X2GI5OV.js';
+import { findProjectRoot } from './chunk-LV6GDBBI.js';
+import { OrchestryError, NotInitializedError } from './chunk-2C2TFQ7K.js';
+import { Command } from 'commander';
+
+// src/cli/context.ts
+function createContext(opts) {
+  const noColor = opts.noColor || "NO_COLOR" in process.env || false;
+  const ascii = opts.ascii || process.env["TERM"] === "dumb" || false;
+  return {
+    projectRoot: findProjectRoot(),
+    json: opts.json ?? false,
+    quiet: opts.quiet ?? false,
+    noColor,
+    ascii
+  };
+}
+
+// src/bin/cli.ts
+var LIGHT_COMMANDS = {
+  task: async (p, c) => {
+    const m = await import('./task-2TJW6Z7O.js');
+    m.registerTaskCommand(p, c);
+  },
+  agent: async (p, c) => {
+    const m = await import('./agent-KBTLGGCT.js');
+    m.registerAgentCommand(p, c);
+  },
+  status: async (p, c) => {
+    const m = await import('./status-RZWN2C6C.js');
+    m.registerStatusCommand(p, c);
+  },
+  logs: async (p, c) => {
+    const m = await import('./logs-PHPYWQ6I.js');
+    m.registerLogsCommand(p, c);
+  },
+  config: async (p, c) => {
+    const m = await import('./config-OTAVSMOD.js');
+    m.registerConfigCommand(p, c);
+  },
+  context: async (p, c) => {
+    const m = await import('./context-OL4BVUV5.js');
+    m.registerContextCommand(p, c);
+  },
+  msg: async (p, c) => {
+    const m = await import('./msg-FUWWLEKM.js');
+    m.registerMsgCommand(p, c);
+  },
+  goal: async (p, c) => {
+    const m = await import('./goal-FMYYN2FR.js');
+    m.registerGoalCommand(p, c);
+  },
+  team: async (p, c) => {
+    const m = await import('./team-PFLP4PPL.js');
+    m.registerTeamCommand(p, c);
+  }
+};
+var FULL_COMMANDS = {
+  run: async (p, c) => {
+    const m = await import('./run-N72G5V2H.js');
+    m.registerRunCommand(p, c);
+  },
+  doctor: async (p, c) => {
+    const m = await import('./doctor-V2FPS236.js');
+    m.registerDoctorCommand(p, c);
+  },
+  tui: async (p, c) => {
+    const m = await import('./tui-IM3YUUVD.js');
+    m.registerTuiCommand(p, c);
+  }
+};
+var program = new Command();
+program.name("orchestry").description("Agents Organizations \u2014 CLI orchestrator for AI agents").version("0.3.4").option("--json", "Output as JSON").option("--quiet", "Minimal output (IDs only)").option("--no-color", "Disable colors").option("--ascii", "ASCII-only output (no Unicode)").hook("preAction", async (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.ascii) setAsciiMode(true);
+  if (opts.color === false) setNoColor(true);
+});
+var COMMAND_STUBS = [
+  ["task", "Manage tasks"],
+  ["agent", "Manage agents"],
+  ["status", "Show orchestrator status"],
+  ["logs", "View run logs"],
+  ["config", "Manage configuration"],
+  ["context", "Shared context store for inter-agent data exchange"],
+  ["msg", "Inter-agent messaging"],
+  ["goal", "Manage goals"],
+  ["team", "Manage teams"],
+  ["run", "Run tasks"],
+  ["doctor", "Check adapters and dependencies"],
+  ["tui", "Launch TUI dashboard"],
+  ["init", "Initialize project"],
+  ["update", "Check for updates"]
+];
+var ALL_KNOWN_COMMANDS = new Set(COMMAND_STUBS.map(([name]) => name));
+async function main() {
+  program.parseOptions(process.argv);
+  const globalOpts = program.opts();
+  const context = createContext({
+    json: globalOpts.json,
+    quiet: globalOpts.quiet,
+    noColor: globalOpts.color === false,
+    ascii: globalOpts.ascii
+  });
+  const sub = process.argv.slice(2).find((arg) => !arg.startsWith("-"));
+  const hasRealSub = sub !== void 0 && ALL_KNOWN_COMMANDS.has(sub);
+  const isHelpOrVersion = process.argv.includes("--help") || process.argv.includes("-h") || process.argv.includes("--version") || process.argv.includes("-V");
+  if (isHelpOrVersion && !hasRealSub) {
+    for (const [name, desc] of COMMAND_STUBS) {
+      program.command(name).description(desc);
+    }
+    await program.parseAsync(process.argv);
+    return;
+  }
+  if (sub === "init") {
+    const { registerInitCommand } = await import('./init-U7MCIOB2.js');
+    registerInitCommand(program);
+  } else if (sub === "update") {
+    const { registerUpdateCommand } = await import('./update-YLP7FPNY.js');
+    registerUpdateCommand(program);
+  }
+  const needsFull = !sub || sub in FULL_COMMANDS;
+  const { buildFullContainer, buildLightContainer } = await import('./container-LJU4QNDH.js');
+  try {
+    if (needsFull) {
+      const container = await buildFullContainer(context);
+      const fullLoader = sub ? FULL_COMMANDS[sub] : void 0;
+      if (fullLoader) {
+        await fullLoader(program, container);
+      } else {
+        await Promise.all(
+          Object.values(FULL_COMMANDS).map((fn) => fn(program, container))
+        );
+      }
+      const lightLoader = sub ? LIGHT_COMMANDS[sub] : void 0;
+      if (lightLoader) {
+        await lightLoader(program, container);
+      }
+    } else {
+      const container = await buildLightContainer(context);
+      const lightLoader = LIGHT_COMMANDS[sub];
+      if (lightLoader) {
+        await lightLoader(program, container);
+      } else {
+        await Promise.all(
+          Object.values(LIGHT_COMMANDS).map((fn) => fn(program, container))
+        );
+      }
+    }
+  } catch (err) {
+    if (err instanceof NotInitializedError) {
+      if (sub === "doctor") {
+        const { registerDoctorCommand } = await import('./doctor-V2FPS236.js');
+        registerDoctorCommand(program);
+      }
+      if (process.argv.length <= 2) {
+        const { runInit } = await import('./init-U7MCIOB2.js');
+        await runInit();
+        const freshContainer = await buildFullContainer(context);
+        await FULL_COMMANDS["tui"](program, freshContainer);
+        await program.parseAsync([...process.argv, "tui"]);
+        return;
+      }
+      if (sub === "init" || sub === "doctor" || sub === "update") {
+        await program.parseAsync(process.argv);
+        return;
+      }
+      printError(err.message, err.hint);
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+  if (process.argv.length <= 2) {
+    process.argv.push("tui");
+  }
+  let updateMod;
+  const skipUpdateCheck = sub === "tui" || sub === "update";
+  const updateCheck = skipUpdateCheck ? Promise.resolve(null) : import('./update-check-4YKLGBFB.js').then((m) => {
+    updateMod = m;
+    return m.checkForUpdateSWR(program.version() ?? "0.0.0");
+  });
+  await program.parseAsync(process.argv);
+  if (!skipUpdateCheck) {
+    const info = await updateCheck;
+    if (info && updateMod) updateMod.printUpdateNotification(info);
+  }
+}
+main().catch((err) => {
+  if (err instanceof OrchestryError) {
+    printError(err.message, err.hint);
+    process.exit(err.exitCode);
+  }
+  printError(
+    err instanceof Error ? err.message : String(err)
+  );
+  if (process.env["ORCHESTRY_DEBUG"]) {
+    console.error(err);
+  }
+  process.exit(1);
+});

package/dist/clipboard-service-RTDUUQQU.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import { OrchestryError } from './chunk-2C2TFQ7K.js';
+import { execFile as execFile$1, execFileSync } from 'child_process';
+import { promisify } from 'util';
+import { mkdtemp, readFile, unlink, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+var execFile = promisify(execFile$1);
+var EXEC_TIMEOUT_MS = 3e3;
+function isClipboardToolAvailable() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return true;
+  }
+  if (platform === "linux") {
+    try {
+      execFileSync("which", ["xclip"], { timeout: EXEC_TIMEOUT_MS, stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (platform === "win32") {
+    return true;
+  }
+  return false;
+}
+async function detectClipboardType() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return detectMacOS();
+  }
+  if (platform === "linux") {
+    return detectLinux();
+  }
+  if (platform === "win32") {
+    return detectWindows();
+  }
+  throw new OrchestryError(
+    `Unsupported platform for clipboard: ${platform}`,
+    1,
+    "Supported: macOS, Linux, Windows"
+  );
+}
+async function getClipboardImage() {
+  const type = await detectClipboardType();
+  if (type !== "image") return null;
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return getImageMacOS();
+  }
+  if (platform === "linux") {
+    return getImageLinux();
+  }
+  if (platform === "win32") {
+    return getImageWindows();
+  }
+  return null;
+}
+async function detectMacOS() {
+  try {
+    const { stdout } = await execFile("osascript", ["-e", "clipboard info"], {
+      timeout: EXEC_TIMEOUT_MS
+    });
+    if (stdout.includes("\xABclass PNGf\xBB") || stdout.includes("\xABclass TIFF\xBB")) {
+      return "image";
+    }
+    if (stdout.includes("\xABclass ut16\xBB") || stdout.includes("\xABclass utf8\xBB")) {
+      return "text";
+    }
+    return stdout.trim().length > 0 ? "text" : "empty";
+  } catch {
+    return "empty";
+  }
+}
+async function getImageMacOS() {
+  const dir = await mkdtemp(join(tmpdir(), "orch-clip-"));
+  const filePath = join(dir, "clipboard.png");
+  try {
+    const script = `
+      set theFile to POSIX file "${filePath}"
+      try
+        set imgData to the clipboard as \xABclass PNGf\xBB
+        set fRef to open for access theFile with write permission
+        write imgData to fRef
+        close access fRef
+        return "ok"
+      on error
+        try
+          close access theFile
+        end try
+        return "error"
+      end try
+    `;
+    const { stdout } = await execFile("osascript", ["-e", script], {
+      timeout: EXEC_TIMEOUT_MS
+    });
+    if (stdout.trim() !== "ok") return null;
+    const data = await readFile(filePath);
+    return { data, ext: "png" };
+  } catch {
+    return null;
+  } finally {
+    try {
+      await unlink(filePath);
+    } catch {
+    }
+    try {
+      await rm(dir, { recursive: true });
+    } catch {
+    }
+  }
+}
+async function detectLinux() {
+  try {
+    const { stdout } = await execFile(
+      "xclip",
+      ["-selection", "clipboard", "-t", "TARGETS", "-o"],
+      { timeout: EXEC_TIMEOUT_MS }
+    );
+    const targets = stdout.toLowerCase();
+    if (targets.includes("image/png") || targets.includes("image/tiff") || targets.includes("image/jpeg")) {
+      return "image";
+    }
+    if (targets.includes("text/plain") || targets.includes("utf8_string") || targets.includes("string")) {
+      return "text";
+    }
+    return targets.trim().length > 0 ? "text" : "empty";
+  } catch {
+    return "empty";
+  }
+}
+async function getImageLinux() {
+  try {
+    const { stdout } = await execFile(
+      "xclip",
+      ["-selection", "clipboard", "-t", "image/png", "-o"],
+      { timeout: EXEC_TIMEOUT_MS, encoding: "buffer", maxBuffer: 50 * 1024 * 1024 }
+    );
+    const data = Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout, "binary");
+    if (data.length === 0) return null;
+    return { data, ext: "png" };
+  } catch {
+    return null;
+  }
+}
+async function detectWindows() {
+  try {
+    const { stdout: imgCheck } = await execFile(
+      "powershell",
+      ["-NoProfile", "-Command", 'if (Get-Clipboard -Format Image) { "image" } else { "none" }'],
+      { timeout: EXEC_TIMEOUT_MS }
+    );
+    if (imgCheck.trim() === "image") return "image";
+    const { stdout: textCheck } = await execFile(
+      "powershell",
+      ["-NoProfile", "-Command", 'if (Get-Clipboard) { "text" } else { "empty" }'],
+      { timeout: EXEC_TIMEOUT_MS }
+    );
+    return textCheck.trim() === "text" ? "text" : "empty";
+  } catch {
+    return "empty";
+  }
+}
+async function getImageWindows() {
+  const dir = await mkdtemp(join(tmpdir(), "orch-clip-"));
+  const filePath = join(dir, "clipboard.png");
+  try {
+    const script = `
+      Add-Type -AssemblyName System.Windows.Forms
+      $img = [System.Windows.Forms.Clipboard]::GetImage()
+      if ($img) {
+        $img.Save('${filePath.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png)
+        Write-Output 'ok'
+      } else {
+        Write-Output 'error'
+      }
+    `;
+    const { stdout } = await execFile("powershell", ["-NoProfile", "-Command", script], {
+      timeout: EXEC_TIMEOUT_MS
+    });
+    if (stdout.trim() !== "ok") return null;
+    const data = await readFile(filePath);
+    return { data, ext: "png" };
+  } catch {
+    return null;
+  } finally {
+    try {
+      await unlink(filePath);
+    } catch {
+    }
+    try {
+      await rm(dir, { recursive: true });
+    } catch {
+    }
+  }
+}
+
+export { detectClipboardType, getClipboardImage, isClipboardToolAvailable };

package/dist/{codex-VBUSA2GJ.js → codex-DIXT44JR.js}

@@ -1,6 +1,7 @@
-import { createStreamingEvents, extractTokens } from './chunk-MGFMVPRD.js';
-import './chunk-XDVMX2FO.js';
-import './chunk-O2MSGW3V.js';
+#!/usr/bin/env node
+import { createStreamingEvents, extractTokens } from './chunk-W6RSVMXR.js';
+import './chunk-CHIP7O6V.js';
+import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 
@@ -14,10 +15,12 @@ var CodexAdapter = class {
     try {
       const { stdout } = await execFileAsync("codex", ["--version"]);
       return { ok: true, version: stdout.trim() };
-    } catch {
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
       return {
         ok: false,
-        error: "Codex CLI not found. Install: npm i -g @openai/codex"
+        error: "Codex CLI not found. Install: npm i -g @openai/codex",
+        errorKind: classifyAdapterError(msg)
       };
     }
   }
@@ -70,7 +73,8 @@ function parseCodexEvent(line) {
       }
       case "turn.failed": {
         const tokens = extractTokens(parsed);
-        return { type: "error", timestamp, data: parsed, tokens };
+        const failMsg = typeof parsed.error === "string" ? parsed.error : JSON.stringify(parsed);
+        return { type: "error", timestamp, data: parsed, tokens, errorKind: classifyAdapterError(failMsg) };
       }
       // Item events
       case "item.started":
@@ -98,12 +102,16 @@ function parseCodexEvent(line) {
           return { type: "output", timestamp, data: item };
         }
         if (itemType === "error") {
-          return { type: "error", timestamp, data: item };
+          const itemErrMsg = typeof item.message === "string" ? item.message : JSON.stringify(item);
+          return { type: "error", timestamp, data: item, errorKind: classifyAdapterError(itemErrMsg) };
         }
         return { type: "output", timestamp, data: item };
       }
-      case "error":
-        return { type: "error", timestamp, data: parsed.error ?? parsed };
+      case "error": {
+        const errData = parsed.error ?? parsed;
+        const errMsg = typeof errData === "string" ? errData : JSON.stringify(errData);
+        return { type: "error", timestamp, data: errData, errorKind: classifyAdapterError(errMsg) };
+      }
       default:
         return { type: "output", timestamp, data: parsed };
     }
@@ -113,5 +121,3 @@ function parseCodexEvent(line) {
 }
 
 export { CodexAdapter };
-//# sourceMappingURL=codex-VBUSA2GJ.js.map
-//# sourceMappingURL=codex-VBUSA2GJ.js.map