@oxgeneral/orch 1.0.1 → 1.0.3

package/dist/clipboard-service-RTDUUQQU.js

@@ -1,200 +0,0 @@
-#!/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-7IXXXG5U.js

@@ -1,123 +0,0 @@
-#!/usr/bin/env node
-import { buildFullPrompt, createStreamingEvents, extractTokens } from './chunk-MGGSRXWJ.js';
-import { classifyAdapterError } from './chunk-2C2TFQ7K.js';
-import './chunk-CHIP7O6V.js';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-
-var execFileAsync = promisify(execFile);
-var CodexAdapter = class {
-  constructor(processManager) {
-    this.processManager = processManager;
-  }
-  kind = "codex";
-  async test() {
-    try {
-      const { stdout } = await execFileAsync("codex", ["--version"]);
-      return { ok: true, version: stdout.trim() };
-    } 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",
-        errorKind: classifyAdapterError(msg)
-      };
-    }
-  }
-  execute(params) {
-    const args = [
-      "exec",
-      "--json",
-      "--sandbox",
-      "danger-full-access"
-      // autonomous agents can't respond to approval prompts
-    ];
-    if (params.config.model) {
-      args.push("--model", params.config.model);
-    }
-    args.push("-");
-    const { process: proc, pid } = this.processManager.spawn("codex", args, {
-      cwd: params.workspace,
-      env: { ...process.env, ...params.env },
-      signal: params.signal,
-      stdio: ["pipe", "pipe", "pipe"]
-      // stdin must be 'pipe' to send prompt
-    });
-    if (proc.stdin) {
-      proc.stdin.write(buildFullPrompt(params.systemPrompt, params.prompt));
-      proc.stdin.end();
-    }
-    const events = createStreamingEvents(proc, parseCodexEvent, "Codex", params.signal);
-    return { pid, events };
-  }
-  async stop(pid) {
-    await this.processManager.killWithGrace(pid);
-  }
-};
-function parseCodexEvent(line) {
-  if (!line.trim()) return null;
-  try {
-    const parsed = JSON.parse(line);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const type = parsed.type ?? "";
-    switch (type) {
-      // Thread/session started
-      case "thread.started":
-        return { type: "output", timestamp, data: parsed };
-      // Turn lifecycle
-      case "turn.started":
-        return { type: "output", timestamp, data: parsed };
-      case "turn.completed": {
-        const tokens = extractTokens(parsed);
-        return { type: "done", timestamp, data: parsed, tokens };
-      }
-      case "turn.failed": {
-        const tokens = extractTokens(parsed);
-        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":
-      case "item.completed": {
-        const item = parsed.item ?? {};
-        const itemType = item.type ?? "";
-        if (itemType === "agent_message") {
-          return { type: "output", timestamp, data: item };
-        }
-        if (itemType === "reasoning") {
-          return { type: "output", timestamp, data: item };
-        }
-        if (itemType === "command_execution") {
-          return { type: "command", timestamp, data: item };
-        }
-        if (itemType === "file_change") {
-          const changes = Array.isArray(item.changes) ? item.changes : [];
-          const paths = changes.map((c) => typeof c.path === "string" ? c.path : "").filter(Boolean);
-          return { type: "file_change", timestamp, data: { paths, raw: item } };
-        }
-        if (itemType === "tool_use") {
-          return { type: "tool_call", timestamp, data: item };
-        }
-        if (itemType === "tool_result") {
-          return { type: "output", timestamp, data: item };
-        }
-        if (itemType === "error") {
-          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": {
-        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 };
-    }
-  } catch {
-    return { type: "output", timestamp: (/* @__PURE__ */ new Date()).toISOString(), data: line };
-  }
-}
-
-export { CodexAdapter };

package/dist/config-OTAVSMOD.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-import { dim, printSuccess, printError } from './chunk-7X2GI5OV.js';
-import { spawn } from 'child_process';
-
-var VALID_FILTER_PRESETS = ["all", "text", "tools", "errors", "events"];
-function registerConfigCommand(program, container) {
-  const config = program.command("config").description("Manage configuration");
-  config.command("get <key>").description("Get a config value (dot notation)").action(async (key) => {
-    await container.paths.requireInit();
-    const value = await container.configStore.get(key);
-    if (container.context.json) {
-      console.log(JSON.stringify({ key, value }));
-    } else {
-      console.log(`  ${dim(key)} = ${JSON.stringify(value)}`);
-    }
-  });
-  config.command("set <key> <value>").description("Set a config value (dot notation)").action(async (key, value) => {
-    await container.paths.requireInit();
-    let parsed;
-    try {
-      parsed = JSON.parse(value);
-    } catch {
-      parsed = value;
-    }
-    await container.configStore.set(key, parsed);
-    printSuccess(`${key} = ${JSON.stringify(parsed)}`);
-  });
-  config.command("edit").description("Open config.yml in $EDITOR").action(async () => {
-    await container.paths.requireInit();
-    const editor = process.env["EDITOR"] || process.env["VISUAL"] || "vi";
-    const parts = editor.split(/\s+/);
-    const child = spawn(parts[0], [...parts.slice(1), container.paths.configPath], {
-      stdio: "inherit"
-    });
-    await new Promise((resolve, reject) => {
-      child.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`Editor exited with code ${code}`));
-      });
-      child.on("error", reject);
-    });
-  });
-  const global = config.command("global").description("Manage global settings (~/.orchestry/global.yml)");
-  global.command("get <key>").description("Get a global config value").action(async (key) => {
-    const gc = await container.globalConfigStore.read();
-    const value = key === "activity_filter" ? gc.tui.activity_filter : void 0;
-    if (container.context.json) {
-      console.log(JSON.stringify({ key, value }));
-    } else {
-      console.log(`  ${dim(key)} = ${JSON.stringify(value)}`);
-    }
-  });
-  global.command("set <key> <value>").description("Set a global config value").action(async (key, value) => {
-    if (key === "activity_filter") {
-      if (!VALID_FILTER_PRESETS.includes(value)) {
-        printError(`Invalid value "${value}". Valid: ${VALID_FILTER_PRESETS.join(", ")}`);
-        return;
-      }
-      await container.globalConfigStore.set("activity_filter", value);
-      printSuccess(`${key} = ${value}`);
-    } else {
-      printError(`Unknown global config key: ${key}`);
-    }
-  });
-  global.command("show").description("Show all global settings").action(async () => {
-    const gc = await container.globalConfigStore.read();
-    if (container.context.json) {
-      console.log(JSON.stringify(gc));
-    } else {
-      console.log(`  ${dim("tui.activity_filter")} = ${gc.tui.activity_filter}`);
-    }
-  });
-}
-
-export { registerConfigCommand };