openviber 0.4.3 → 0.5.1

package/dist/index.js

@@ -4514,21 +4514,38 @@ import * as path8 from "path";
 import * as yaml2 from "yaml";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getDefaultSkillsPath() {
-  const cwdPath = path8.resolve(process.cwd(), "src/skills");
+  const userSkillsPath = path8.join(getViberRoot(), "skills");
   try {
-    fsSync.accessSync(cwdPath);
-    console.log(`[SkillRegistry] Using skills path (cwd): ${cwdPath}`);
-    return cwdPath;
+    fsSync.accessSync(userSkillsPath);
+    console.log(`[SkillRegistry] Using skills path (user): ${userSkillsPath}`);
+    return userSkillsPath;
   } catch {
-    const relativePath = path8.resolve(__dirname2, ".");
+    const bundledPath = path8.resolve(__dirname2, ".");
     try {
-      fsSync.accessSync(relativePath);
-      console.log(`[SkillRegistry] Using skills path (relative): ${relativePath}`);
-      return relativePath;
+      fsSync.accessSync(bundledPath);
+      const hasSkillDirs = fsSync.readdirSync(bundledPath).some((f) => {
+        const skillMd = path8.join(bundledPath, f, "SKILL.md");
+        try {
+          fsSync.accessSync(skillMd);
+          return true;
+        } catch {
+          return false;
+        }
+      });
+      if (hasSkillDirs) {
+        console.log(`[SkillRegistry] Using skills path (bundled): ${bundledPath}`);
+        return bundledPath;
+      }
     } catch {
-      const viberPath = path8.join(getViberRoot(), "skills");
-      console.log(`[SkillRegistry] Using skills path (viber root): ${viberPath}`);
-      return viberPath;
+    }
+    const devPath = path8.resolve(process.cwd(), "src/skills");
+    try {
+      fsSync.accessSync(devPath);
+      console.log(`[SkillRegistry] Using skills path (dev): ${devPath}`);
+      return devPath;
+    } catch {
+      console.log(`[SkillRegistry] Using skills path (default): ${userSkillsPath}`);
+      return userSkillsPath;
     }
   }
 }
@@ -7347,103 +7364,33 @@ async function runTask(goal, options, messages) {
 }
 
 // src/daemon/terminal.ts
-import { spawn, execSync } from "child_process";
+import { spawn, spawnSync, execSync } from "child_process";
 import { EventEmitter } from "events";
-function listSessions() {
-  try {
-    const out = execSync(
-      "tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_attached}' 2>/dev/null",
-      { encoding: "utf8", stdio: "pipe" }
-    ).trim();
-    if (!out) return [];
-    return out.split("\n").map((line) => {
-      const [name, windows, attached] = line.split("|");
-      return {
-        name,
-        windows: parseInt(windows, 10) || 0,
-        attached: attached === "1"
-      };
-    });
-  } catch {
-    return [];
-  }
-}
-function listPanes() {
-  try {
-    const out = execSync(
-      "tmux list-panes -a -F '#{session_name}|#{window_index}|#{window_name}|#{pane_index}|#{pane_current_command}' 2>/dev/null",
-      { encoding: "utf8", stdio: "pipe" }
-    ).trim();
-    if (!out) return [];
-    return out.split("\n").map((line) => {
-      const [session, window2, windowName, pane, command] = line.split("|");
-      return {
-        session,
-        window: window2,
-        windowName,
-        pane,
-        command,
-        target: `${session}:${window2}.${pane}`
-      };
-    });
-  } catch {
-    return [];
-  }
+import { randomUUID } from "crypto";
+var SAFE_NAME_RE = /[^a-zA-Z0-9_.:-]/g;
+function sanitizeName(input) {
+  return input.replace(SAFE_NAME_RE, "-");
 }
-function sendKeys(target, keys, pressEnter = false) {
-  try {
-    const args = ["send-keys", "-t", target, keys];
-    if (pressEnter) args.push("Enter");
-    execSync(`tmux ${args.map((a) => `'${a}'`).join(" ")}`, {
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function capturePane(target, lines = 500) {
-  const cmds = [
-    `tmux capture-pane -t '${target}' -pae -S -${lines}`,
-    `tmux capture-pane -t '${target}' -pe -S -${lines}`
-  ];
-  for (const cmd of cmds) {
-    try {
-      return execSync(cmd, { encoding: "utf8", stdio: "pipe" });
-    } catch {
-    }
-  }
-  return "";
-}
-function resizePane(target, cols, rows) {
-  try {
-    execSync(`tmux resize-pane -t '${target}' -x ${cols} -y ${rows}`, {
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
+function resolveAppTarget(target, appHint) {
+  if (target.includes("::")) {
+    const [appId, ...rest] = target.split("::");
+    return { appId, rawTarget: rest.join("::") };
   }
+  return { appId: appHint || "tmux", rawTarget: target };
 }
-var TerminalStream = class extends EventEmitter {
-  target;
-  catProcess = null;
-  pipePath;
-  isAttached = false;
+var TmuxTerminalStream = class extends EventEmitter {
   constructor(target) {
     super();
     this.target = target;
     this.pipePath = `/tmp/viber-term-${target.replace(/[^a-zA-Z0-9]/g, "-")}-${Date.now()}`;
   }
-  /**
-   * Start streaming the pane output
-   */
+  catProcess = null;
+  pipePath;
+  isAttached = false;
   async attach() {
     if (this.isAttached) return true;
     try {
-      const history = capturePane(this.target, 200);
+      const history = captureTmuxPane(this.target, 200);
       if (history) {
         this.emit("data", history);
       }
@@ -7473,9 +7420,6 @@ var TerminalStream = class extends EventEmitter {
       return false;
     }
   }
-  /**
-   * Stop streaming
-   */
   detach() {
     if (!this.isAttached) return;
     try {
@@ -7484,12 +7428,6 @@ var TerminalStream = class extends EventEmitter {
     }
     this.cleanup();
   }
-  /**
-   * Send input to the pane
-   */
-  sendInput(keys) {
-    return sendKeys(this.target, keys, false);
-  }
   cleanup() {
     this.isAttached = false;
     if (this.catProcess) {
@@ -7506,20 +7444,61 @@ var TerminalStream = class extends EventEmitter {
     return this.isAttached;
   }
 };
-var TerminalManager = class {
+var TmuxTerminalApp = class {
+  id = "tmux";
+  label = "tmux";
   streams = /* @__PURE__ */ new Map();
-  /**
-   * List all available terminals
-   */
-  list() {
-    return {
-      sessions: listSessions(),
-      panes: listPanes()
-    };
+  isAvailable() {
+    try {
+      execSync("tmux -V", { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  listSessions() {
+    try {
+      const out = execSync(
+        "tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_attached}' 2>/dev/null",
+        { encoding: "utf8", stdio: "pipe" }
+      ).trim();
+      if (!out) return [];
+      return out.split("\n").map((line) => {
+        const [name, windows, attached] = line.split("|");
+        return {
+          appId: this.id,
+          name,
+          windows: parseInt(windows, 10) || 0,
+          attached: attached === "1"
+        };
+      });
+    } catch {
+      return [];
+    }
+  }
+  listPanes() {
+    try {
+      const out = execSync(
+        "tmux list-panes -a -F '#{session_name}|#{window_index}|#{window_name}|#{pane_index}|#{pane_current_command}' 2>/dev/null",
+        { encoding: "utf8", stdio: "pipe" }
+      ).trim();
+      if (!out) return [];
+      return out.split("\n").map((line) => {
+        const [session, window2, windowName, pane, command] = line.split("|");
+        return {
+          appId: this.id,
+          session,
+          window: window2,
+          windowName,
+          pane,
+          command,
+          target: `${session}:${window2}.${pane}`
+        };
+      });
+    } catch {
+      return [];
+    }
   }
-  /**
-   * Attach to a pane and return the stream
-   */
   async attach(target, onData, onClose) {
     let stream = this.streams.get(target);
     if (stream && stream.attached) {
@@ -7527,7 +7506,7 @@ var TerminalManager = class {
       stream.on("close", onClose);
       return true;
     }
-    stream = new TerminalStream(target);
+    stream = new TmuxTerminalStream(target);
     stream.on("data", onData);
     stream.on("close", () => {
       this.streams.delete(target);
@@ -7539,31 +7518,62 @@ var TerminalManager = class {
     }
     return ok;
   }
-  /**
-   * Detach from a pane
-   */
   detach(target) {
     const stream = this.streams.get(target);
-    if (stream) {
-      stream.detach();
-      this.streams.delete(target);
-    }
+    if (!stream) return;
+    stream.detach();
+    this.streams.delete(target);
   }
-  /**
-   * Send input to a pane
-   */
   sendInput(target, keys) {
-    return sendKeys(target, keys, false);
+    return sendTmuxKeys(target, keys);
   }
-  /**
-   * Resize pane to match web terminal
-   */
   resize(target, cols, rows) {
-    return resizePane(target, cols, rows);
+    try {
+      execSync(`tmux resize-pane -t '${target}' -x ${cols} -y ${rows}`, {
+        encoding: "utf8",
+        stdio: "pipe"
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  createSession(sessionName, windowName = "main", cwd) {
+    const safeSession = sanitizeName(sessionName || "coding");
+    const safeWindow = sanitizeName(windowName || "main");
+    try {
+      execSync(`tmux has-session -t '${safeSession}' 2>/dev/null`, { stdio: "pipe" });
+      return { ok: true, appId: this.id, sessionName: safeSession, created: false };
+    } catch {
+    }
+    const args = ["new-session", "-d", "-s", safeSession, "-n", safeWindow];
+    if (cwd) {
+      args.push("-c", cwd);
+    }
+    const result = spawnSync("tmux", args, {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    if (result.error) {
+      return {
+        ok: false,
+        appId: this.id,
+        sessionName: safeSession,
+        created: false,
+        error: `Failed to start tmux: ${result.error.message}`
+      };
+    }
+    if (result.status !== 0) {
+      return {
+        ok: false,
+        appId: this.id,
+        sessionName: safeSession,
+        created: false,
+        error: (result.stderr || result.stdout || "Failed to create tmux session").trim()
+      };
+    }
+    return { ok: true, appId: this.id, sessionName: safeSession, created: true };
   }
-  /**
-   * Detach all streams
-   */
   detachAll() {
     for (const stream of this.streams.values()) {
       stream.detach();
@@ -7571,6 +7581,203 @@ var TerminalManager = class {
     this.streams.clear();
   }
 };
+var ShellTerminalApp = class {
+  id = "shell";
+  label = "shell";
+  sessions = /* @__PURE__ */ new Map();
+  isAvailable() {
+    return true;
+  }
+  listSessions() {
+    return Array.from(this.sessions.values()).map((state) => ({
+      appId: this.id,
+      name: state.sessionName,
+      windows: 1,
+      attached: state.listeners.size > 0
+    }));
+  }
+  listPanes() {
+    return Array.from(this.sessions.entries()).map(([id, state]) => ({
+      appId: this.id,
+      session: state.sessionName,
+      window: "0",
+      windowName: state.windowName,
+      pane: state.pane,
+      command: process.env.SHELL || "sh",
+      target: id
+    }));
+  }
+  async attach(target, onData, onClose) {
+    const state = this.sessions.get(target);
+    if (!state) return false;
+    state.listeners.add(onData);
+    state.closeListeners.add(onClose);
+    if (state.history.length > 0) {
+      onData(state.history.join(""));
+    }
+    return true;
+  }
+  detach(target) {
+    const state = this.sessions.get(target);
+    if (!state) return;
+    state.listeners.clear();
+    state.closeListeners.clear();
+  }
+  sendInput(target, keys) {
+    const state = this.sessions.get(target);
+    if (!state || !state.proc.stdin?.writable) return false;
+    state.proc.stdin.write(keys);
+    return true;
+  }
+  resize(_target, _cols, _rows) {
+    return true;
+  }
+  createSession(sessionName, windowName = "main", cwd) {
+    const safeSession = sanitizeName(sessionName || `shell-${Date.now()}`);
+    const shell = process.env.SHELL || "sh";
+    const target = `${safeSession}:${randomUUID().slice(0, 8)}`;
+    if (this.sessions.has(target)) {
+      return { ok: true, appId: this.id, sessionName: safeSession, created: false };
+    }
+    const proc = spawn(shell, [], {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env
+    });
+    if (!proc.pid) {
+      return {
+        ok: false,
+        appId: this.id,
+        sessionName: safeSession,
+        created: false,
+        error: "Failed to start shell process"
+      };
+    }
+    const state = {
+      proc,
+      sessionName: safeSession,
+      windowName,
+      pane: "0",
+      history: [],
+      listeners: /* @__PURE__ */ new Set(),
+      closeListeners: /* @__PURE__ */ new Set()
+    };
+    const pushChunk = (chunk) => {
+      const text = chunk.toString();
+      state.history.push(text);
+      if (state.history.length > 200) {
+        state.history.shift();
+      }
+      for (const listener of state.listeners) {
+        listener(text);
+      }
+    };
+    proc.stdout?.on("data", pushChunk);
+    proc.stderr?.on("data", pushChunk);
+    proc.on("close", () => {
+      for (const onClose of state.closeListeners) {
+        onClose();
+      }
+      this.sessions.delete(target);
+    });
+    this.sessions.set(target, state);
+    return { ok: true, appId: this.id, sessionName: safeSession, created: true };
+  }
+  detachAll() {
+    for (const [id, state] of this.sessions.entries()) {
+      state.proc.kill();
+      this.sessions.delete(id);
+    }
+  }
+};
+function sendTmuxKeys(target, keys, pressEnter = false) {
+  try {
+    const args = ["send-keys", "-t", target, keys];
+    if (pressEnter) args.push("Enter");
+    execSync(`tmux ${args.map((a) => `'${a}'`).join(" ")}`, {
+      encoding: "utf8",
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function captureTmuxPane(target, lines = 500) {
+  const cmds = [
+    `tmux capture-pane -t '${target}' -pae -S -${lines}`,
+    `tmux capture-pane -t '${target}' -pe -S -${lines}`
+  ];
+  for (const cmd of cmds) {
+    try {
+      return execSync(cmd, { encoding: "utf8", stdio: "pipe" });
+    } catch {
+    }
+  }
+  return "";
+}
+var TerminalManager = class {
+  apps = /* @__PURE__ */ new Map();
+  constructor(adapters) {
+    const defaultAdapters = adapters ?? [new TmuxTerminalApp(), new ShellTerminalApp()];
+    for (const adapter of defaultAdapters) {
+      this.apps.set(adapter.id, adapter);
+    }
+  }
+  list() {
+    const metadata = Array.from(this.apps.values()).map((app) => ({
+      id: app.id,
+      label: app.label,
+      available: app.isAvailable()
+    }));
+    const sessions = [];
+    const panes = [];
+    for (const app of this.apps.values()) {
+      if (!app.isAvailable()) continue;
+      sessions.push(...app.listSessions());
+      panes.push(...app.listPanes());
+    }
+    return { apps: metadata, sessions, panes };
+  }
+  async attach(target, onData, onClose, appHint) {
+    const { appId, rawTarget } = resolveAppTarget(target, appHint);
+    const app = this.apps.get(appId);
+    if (!app || !app.isAvailable()) return false;
+    return app.attach(rawTarget, onData, onClose);
+  }
+  detach(target, appHint) {
+    const { appId, rawTarget } = resolveAppTarget(target, appHint);
+    this.apps.get(appId)?.detach(rawTarget);
+  }
+  sendInput(target, keys, appHint) {
+    const { appId, rawTarget } = resolveAppTarget(target, appHint);
+    const app = this.apps.get(appId);
+    return !!app && app.isAvailable() ? app.sendInput(rawTarget, keys) : false;
+  }
+  resize(target, cols, rows, appHint) {
+    const { appId, rawTarget } = resolveAppTarget(target, appHint);
+    const app = this.apps.get(appId);
+    return !!app && app.isAvailable() ? app.resize(rawTarget, cols, rows) : false;
+  }
+  createSession(sessionName, windowName = "main", cwd, appId = "tmux") {
+    const app = this.apps.get(appId);
+    if (!app || !app.isAvailable()) {
+      return {
+        ok: false,
+        appId,
+        sessionName,
+        created: false,
+        error: `Terminal app '${appId}' is not available`
+      };
+    }
+    return app.createSession(sessionName, windowName, cwd);
+  }
+  detachAll() {
+    for (const app of this.apps.values()) {
+      app.detachAll();
+    }
+  }
+};
 
 // src/daemon/controller.ts
 var ViberController = class extends EventEmitter2 {
@@ -7721,16 +7928,16 @@ var ViberController = class extends EventEmitter2 {
           this.handleTerminalList();
           break;
         case "terminal:attach":
-          await this.handleTerminalAttach(message.target);
+          await this.handleTerminalAttach(message.target, message.appId);
           break;
         case "terminal:detach":
-          this.handleTerminalDetach(message.target);
+          this.handleTerminalDetach(message.target, message.appId);
           break;
         case "terminal:input":
-          this.handleTerminalInput(message.target, message.keys);
+          this.handleTerminalInput(message.target, message.keys, message.appId);
           break;
         case "terminal:resize":
-          this.handleTerminalResize(message.target, message.cols, message.rows);
+          this.handleTerminalResize(message.target, message.cols, message.rows, message.appId);
           break;
       }
     } catch (error) {
@@ -7760,7 +7967,87 @@ var ViberController = class extends EventEmitter2 {
         },
         messages
       );
-      const finalText = await streamResult.text;
+      let finalText = "";
+      let pendingDelta = "";
+      let lastProgressAt = 0;
+      const flushProgress = (force = false) => {
+        if (!pendingDelta) return;
+        const now = Date.now();
+        if (!force && now - lastProgressAt < 250) return;
+        this.send({
+          type: "task:progress",
+          taskId,
+          event: {
+            kind: "text-delta",
+            delta: pendingDelta,
+            totalLength: finalText.length,
+            at: new Date(now).toISOString()
+          }
+        });
+        pendingDelta = "";
+        lastProgressAt = now;
+      };
+      this.send({
+        type: "task:progress",
+        taskId,
+        event: {
+          kind: "status",
+          phase: "executing",
+          message: "Agent execution started",
+          at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      for await (const part of streamResult.fullStream) {
+        switch (part.type) {
+          case "text-delta":
+            if (part.text) {
+              finalText += part.text;
+              pendingDelta += part.text;
+              flushProgress(false);
+            }
+            break;
+          case "tool-call":
+            this.send({
+              type: "task:progress",
+              taskId,
+              event: {
+                kind: "tool-call",
+                toolName: part.toolName,
+                toolCallId: part.toolCallId,
+                at: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            });
+            break;
+          case "tool-result":
+            this.send({
+              type: "task:progress",
+              taskId,
+              event: {
+                kind: "tool-result",
+                toolCallId: part.toolCallId,
+                at: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            });
+            break;
+          case "error":
+            throw new Error(part.error?.message || "Task stream error");
+          case "finish":
+            flushProgress(true);
+            this.send({
+              type: "task:progress",
+              taskId,
+              event: {
+                kind: "status",
+                phase: "verifying",
+                message: "Agent execution finished, preparing final output",
+                at: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            });
+            break;
+          default:
+            break;
+        }
+      }
       this.send({
         type: "task:completed",
         taskId,
@@ -7797,33 +8084,34 @@ var ViberController = class extends EventEmitter2 {
   }
   // ==================== Terminal Streaming ====================
   handleTerminalList() {
-    const { sessions, panes } = this.terminalManager.list();
-    this.send({ type: "terminal:list", sessions, panes });
+    const { apps, sessions, panes } = this.terminalManager.list();
+    this.send({ type: "terminal:list", apps, sessions, panes });
   }
-  async handleTerminalAttach(target) {
+  async handleTerminalAttach(target, appId) {
     console.log(`[Viber] Attaching to terminal: ${target}`);
     const ok = await this.terminalManager.attach(
       target,
       (data) => {
-        this.send({ type: "terminal:output", target, data });
+        this.send({ type: "terminal:output", target, appId, data });
       },
       () => {
-        this.send({ type: "terminal:detached", target });
-      }
+        this.send({ type: "terminal:detached", target, appId });
+      },
+      appId
     );
-    this.send({ type: "terminal:attached", target, ok });
+    this.send({ type: "terminal:attached", target, appId, ok });
   }
-  handleTerminalDetach(target) {
+  handleTerminalDetach(target, appId) {
     console.log(`[Viber] Detaching from terminal: ${target}`);
-    this.terminalManager.detach(target);
-    this.send({ type: "terminal:detached", target });
+    this.terminalManager.detach(target, appId);
+    this.send({ type: "terminal:detached", target, appId });
   }
-  handleTerminalInput(target, keys) {
-    this.terminalManager.sendInput(target, keys);
+  handleTerminalInput(target, keys, appId) {
+    this.terminalManager.sendInput(target, keys, appId);
   }
-  handleTerminalResize(target, cols, rows) {
-    const ok = this.terminalManager.resize(target, cols, rows);
-    this.send({ type: "terminal:resized", target, ok });
+  handleTerminalResize(target, cols, rows, appId) {
+    const ok = this.terminalManager.resize(target, cols, rows, appId);
+    this.send({ type: "terminal:resized", target, appId, ok });
   }
   // ==================== Communication ====================
   send(message) {