@vibe80/vibe80 0.1.1

package/git_hooks/prepare-commit-msg

@@ -0,0 +1,35 @@
+#!/bin/sh
+set -eu
+
+MSG_FILE="$1"
+COMMIT_SOURCE="${2-}"
+SHA1="${3-}"
+
+# Ne pas modifier les messages par défaut lors d'un merge ou d'un squash
+case "$COMMIT_SOURCE" in
+  merge|squash) exit 0 ;;
+esac
+
+# Récupération des valeurs depuis la config du worktree
+sessionId="$(git config --worktree --get vibe80.sessionId || true)"
+worktreeId="$(git config --worktree --get vibe80.worktreeId || true)"
+
+# Flag d’activation (stdout uniquement)
+includeMetadata="$(git config --get vibe80.includeCommitMetadata || true)"
+
+# Fonction: ajouter "Key: value" si absent
+add_if_missing() {
+  key="$1"
+  value="$2"
+  # Si déjà présent (même vide), on ne touche pas
+  if grep -q "^$key:" "$MSG_FILE"; then
+    return 0
+  fi
+
+  printf "\n%s: %s\n" "$key" "$value" >> "$MSG_FILE"
+}
+
+# Ajout conditionnel
+if [ "$includeMetadata" = "1" ]; then
+  add_if_missing "VIBE80-Tag" "${sessionId}/${worktreeId}"
+fi

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@vibe80/vibe80",
+  "version": "0.1.1",
+  "private": false,
+  "workspaces": [
+    "server",
+    "client"
+  ],
+  "bin": {
+    "vibe80": "bin/vibe80.js"
+  },
+  "files": [
+    "bin",
+    "git_hooks",
+    "server",
+    "client",
+    "package.json",
+    "package-lock.json",
+    "README.md",
+    "docs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "concurrently -n server,client -c blue,green \"npm:dev:server\" \"npm:dev:client\"",
+    "dev:server": "npm --workspace server run dev",
+    "dev:client": "npm --workspace client run dev",
+    "build": "npm --workspace client run build",
+    "start": "npm --workspace server run start"
+  },
+  "dependencies": {
+    "concurrently": "^8.2.2"
+  },
+  "license": "Apache-2.0"
+}

package/server/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "vibe80-server",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch src/index.js",
+    "start": "node src/index.js",
+    "workspace:rotate-secret": "node scripts/rotate-workspace-secret.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "docker-names": "^1.2.1",
+    "express": "^4.19.2",
+    "express-rate-limit": "^7.4.0",
+    "jsonwebtoken": "^9.0.3",
+    "multer": "^1.4.5-lts.1",
+    "node-pty": "^1.0.0",
+    "redis": "^4.7.1",
+    "sqlite3": "^5.1.7",
+    "ws": "^8.17.1"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "supertest": "^7.2.2",
+    "vitest": "^4.0.18"
+  }
+}

package/server/scripts/rotate-workspace-secret.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import storage from "../src/storage/index.js";
+import {
+  workspaceIdPattern,
+  rotateWorkspaceSecret,
+} from "../src/services/workspace.js";
+
+const printUsage = () => {
+  console.error(
+    [
+      "Usage:",
+      "  node server/scripts/rotate-workspace-secret.js --workspace-id <workspaceId> [--workspace-secret <secret>] [--json]",
+      "",
+      "Requirements:",
+      "  - SERVER env vars must be set (e.g. STORAGE_BACKEND, DEPLOYMENT_MODE, etc.)",
+    ].join("\n")
+  );
+};
+
+const parseArgs = (argv) => {
+  const args = {
+    workspaceId: "",
+    workspaceSecret: "",
+    json: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--workspace-id") {
+      args.workspaceId = String(argv[i + 1] || "").trim();
+      i += 1;
+      continue;
+    }
+    if (token === "--workspace-secret") {
+      args.workspaceSecret = String(argv[i + 1] || "");
+      i += 1;
+      continue;
+    }
+    if (token === "--json") {
+      args.json = true;
+      continue;
+    }
+    if (token === "-h" || token === "--help") {
+      args.help = true;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${token}`);
+  }
+
+  return args;
+};
+
+const main = async () => {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printUsage();
+    process.exit(0);
+  }
+
+  if (!args.workspaceId) {
+    throw new Error("--workspace-id is required.");
+  }
+
+  if (!workspaceIdPattern.test(args.workspaceId)) {
+    throw new Error(`Invalid workspaceId: ${args.workspaceId}`);
+  }
+
+  if (args.workspaceSecret.trim() === "") {
+    args.workspaceSecret = "";
+  }
+
+  await storage.init();
+  try {
+    const result = await rotateWorkspaceSecret(args.workspaceId, {
+      workspaceSecret: args.workspaceSecret || undefined,
+      actor: "cli",
+    });
+
+    if (args.json) {
+      process.stdout.write(`${JSON.stringify(result)}\n`);
+      return;
+    }
+
+    process.stdout.write(
+      [
+        "Workspace secret rotated successfully.",
+        `workspaceId=${result.workspaceId}`,
+        `workspaceSecret=${result.workspaceSecret}`,
+      ].join("\n") + "\n"
+    );
+  } finally {
+    await storage.close();
+  }
+};
+
+main().catch((error) => {
+  console.error(error?.message || error);
+  printUsage();
+  process.exit(1);
+});

package/server/src/claudeClient.js

@@ -0,0 +1,454 @@
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import crypto from "crypto";
+import path from "path";
+import { SYSTEM_PROMPT } from "./config.js";
+import { createProviderLogger } from "./providerLogger.js";
+import { buildSandboxArgs, getWorkspaceHome, runAsCommand } from "./runAs.js";
+
+const RUN_AS_HELPER = process.env.VIBE80_RUN_AS_HELPER || "/usr/local/bin/vibe80-run-as";
+const SUDO_PATH = process.env.VIBE80_SUDO_PATH || "sudo";
+const isMonoUser = process.env.DEPLOYMENT_MODE === "mono_user";
+
+const createTurnId = () =>
+  typeof crypto.randomUUID === "function"
+    ? crypto.randomUUID()
+    : crypto.randomBytes(16).toString("hex");
+
+export class ClaudeCliClient extends EventEmitter {
+  constructor({
+    cwd,
+    attachmentsDir,
+    repoDir,
+    internetAccess,
+    denyGitCredentialsAccess,
+    gitDir,
+    env,
+    workspaceId,
+    tmpDir,
+    sessionId,
+    worktreeId,
+    threadId,
+    forkFromThreadId,
+  }) {
+    super();
+    this.cwd = cwd;
+    this.attachmentsDir = attachmentsDir;
+    this.repoDir = repoDir || cwd;
+    this.internetAccess = internetAccess ?? true;
+    this.denyGitCredentialsAccess = denyGitCredentialsAccess ?? true;
+    if (this.internetAccess === false && this.denyGitCredentialsAccess) {
+      throw new Error(
+        "Invalid Claude configuration: denyGitCredentialsAccess must be false when internetAccess is false."
+      );
+    }
+    this.gitDir = gitDir || null;
+    this.env = env || process.env;
+    this.workspaceId = workspaceId;
+    this.tmpDir = tmpDir || null;
+    this.sessionId = sessionId || null;
+    this.worktreeId = worktreeId || "main";
+    this.ready = false;
+    this.threadId = threadId || null;
+    this.pendingForkFromThreadId = forkFromThreadId || null;
+    this.modelInfo = null;
+    this.defaultModel = null;
+    this.toolUses = new Map();
+    this.buffer = "";
+    this.stdoutLogBuffer = "";
+    this.stderrLogBuffer = "";
+    this.providerLogger = createProviderLogger({
+      provider: "claude",
+      sessionId: this.sessionId,
+      worktreeId: this.worktreeId,
+    });
+    this.systemPrompt = SYSTEM_PROMPT;
+    this.activeProcess = null;
+  }
+
+  async start() {
+    this.ready = true;
+    this.emit("ready", { threadId: this.threadId });
+  }
+
+  async stop() {
+    const proc = this.activeProcess;
+    if (!proc) {
+      return;
+    }
+    this.activeProcess = null;
+    this.ready = false;
+    const exitPromise = new Promise((resolve) => {
+      proc.once("exit", resolve);
+      proc.once("close", resolve);
+    });
+    try {
+      proc.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    await Promise.race([
+      exitPromise,
+      new Promise((resolve) => setTimeout(resolve, 5000)),
+    ]);
+    if (!proc.killed) {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+        return;
+      }
+      await exitPromise;
+    }
+  }
+
+  getStatus() {
+    if (this.activeProcess) {
+      return "busy";
+    }
+    if (!this.ready) {
+      return "starting";
+    }
+    return "idle";
+  }
+
+  requestRestart() {
+    return;
+  }
+
+  async restart() {
+    return;
+  }
+
+  async sendTurn(text) {
+    const turnId = createTurnId();
+    const workspaceHome = getWorkspaceHome(this.workspaceId);
+    const claudeConfigPath = path.join(workspaceHome, ".claude.json");
+    try {
+      await runAsCommand(
+        this.workspaceId,
+        "/bin/sh",
+        [
+          "-c",
+          'if [ ! -f "$1" ]; then printf "{}" > "$1"; fi',
+          "sh",
+          claudeConfigPath,
+        ],
+        { cwd: workspaceHome }
+      );
+    } catch (error) {
+      this.emit(
+        "log",
+        `Unable to ensure Claude config exists: ${error?.message || error}`
+      );
+    }
+    const shareGitCredentials = !this.denyGitCredentialsAccess;
+    const sshDir = path.join(getWorkspaceHome(this.workspaceId), ".ssh");
+    const allowedDirs = [
+      this.cwd,
+      this.repoDir,
+      this.attachmentsDir,
+      shareGitCredentials ? this.gitDir : null,
+      shareGitCredentials ? sshDir : null,
+    ]
+      .filter(Boolean)
+      .filter((value, index, self) => self.indexOf(value) === index);
+    const allowedTools = ["Bash"];
+    if (this.internetAccess) {
+      allowedTools.push("WebSearch");
+      allowedTools.push("WebFetch");
+    }
+    const shouldForkSession =
+      !this.threadId &&
+      typeof this.pendingForkFromThreadId === "string" &&
+      this.pendingForkFromThreadId.trim();
+    const args = [
+      ...(shouldForkSession
+        ? ["--fork-session", "--resume", this.pendingForkFromThreadId.trim()]
+        : ["--continue"]),
+      "--verbose",
+      "-p",
+      ...(this.defaultModel ? ["--model", this.defaultModel] : []),
+      "--output-format",
+      "stream-json",
+      "--input-format",
+      "stream-json",
+      "--permission-mode",
+      "acceptEdits",
+      "--allowed-tools",
+      allowedTools.join(" "),
+      "--append-system-prompt",
+      this.systemPrompt,
+    ];
+    for (const dir of allowedDirs) {
+      args.push("--add-dir", dir);
+    }
+
+    const command = "claude";
+    const spawnCommand = isMonoUser ? command : SUDO_PATH;
+    const spawnArgs = isMonoUser
+      ? args
+      : [
+          "-n",
+          RUN_AS_HELPER,
+          "--workspace-id",
+          this.workspaceId,
+          "--cwd",
+          this.cwd,
+          ...buildSandboxArgs({
+            cwd: this.cwd,
+            repoDir: this.repoDir,
+            attachmentsDir: this.attachmentsDir,
+            tmpDir: this.tmpDir,
+            workspaceId: this.workspaceId,
+            internetAccess: this.internetAccess,
+            netMode: "tcp:22,53,443",
+            extraAllowRw: [
+              path.join(getWorkspaceHome(this.workspaceId), ".claude"),
+              ...(shareGitCredentials
+                ? [sshDir, ...(this.gitDir ? [this.gitDir] : [])]
+                : []),
+            ],
+            extraAllowRwFiles: [
+              path.join(getWorkspaceHome(this.workspaceId), ".claude.json"),
+            ],
+          }),
+          "--",
+          command,
+          ...args,
+        ];
+
+    const proc = spawn(spawnCommand, spawnArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: this.env,
+      cwd: isMonoUser ? this.cwd : undefined,
+    });
+    this.activeProcess = proc;
+
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => {
+      this.#logStreamChunk("OUT", "stdoutLogBuffer", chunk);
+      this.#handleStdout(turnId, chunk);
+    });
+
+    proc.stderr.setEncoding("utf8");
+    proc.stderr.on("data", (chunk) => {
+      this.#logStreamChunk("ERR", "stderrLogBuffer", chunk);
+      const message = chunk.toString().trim();
+      if (message) {
+        this.emit("log", message);
+      }
+    });
+
+    this.emit("turn_started", { turnId, status: "processing" });
+
+    proc.on("error", (error) => {
+      const details = [
+        "Claude spawn failed",
+        `mode=${isMonoUser ? "mono_user" : "multi_user"}`,
+        isMonoUser ? `cmd=${command}` : `sudo=${SUDO_PATH}`,
+        isMonoUser ? null : `helper=${RUN_AS_HELPER}`,
+        `workspace=${this.workspaceId}`,
+        `cwd=${this.cwd}`,
+        `error=${error?.message || error}`,
+      ]
+        .filter(Boolean)
+        .join(" ");
+      this.emit("log", details);
+      this.emit("turn_error", {
+        turnId,
+        message: details,
+      });
+    });
+
+    proc.on("close", (code) => {
+      if (this.activeProcess === proc) {
+        this.activeProcess = null;
+      }
+      this.#flushLogBuffer("OUT", "stdoutLogBuffer");
+      this.#flushLogBuffer("ERR", "stderrLogBuffer");
+      this.providerLogger?.close?.();
+      if (code === 0) {
+        this.emit("turn_completed", { turnId, status: "success" });
+      } else {
+        this.emit("turn_error", {
+          turnId,
+          message: `Claude process exited with code ${code}`,
+        });
+      }
+    });
+
+    const payload = {
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text }],
+      },
+    };
+    const line = JSON.stringify(payload);
+    this.providerLogger?.writeLine("IN", line);
+    proc.stdin.write(`${line}\n`);
+    proc.stdin.end();
+
+    return { turn: { id: turnId } };
+  }
+
+  async interruptTurn() {
+    if (this.activeProcess && !this.activeProcess.killed) {
+      this.activeProcess.kill("SIGTERM");
+      return;
+    }
+    throw new Error("Claude CLI does not have an active process to interrupt.");
+  }
+
+  async listModels() {
+    const model = this.modelInfo?.model || "default";
+    return {
+      data: [
+        {
+          id: "default",
+          model: "default",
+          displayName: "default",
+          isDefault: true,
+        },
+        { id: "sonnet", model: "sonnet", displayName: "sonnet" },
+        { id: "opus", model: "opus", displayName: "opus" },
+        { id: "haiku", model: "haiku", displayName: "haiku" },
+        { id: "opusplan", model: "opusplan", displayName: "opusplan" },
+      ],
+      nextCursor: null,
+    };
+  }
+
+  async setDefaultModel(model) {
+    if (typeof model === "string" && model.trim()) {
+      this.defaultModel = model.trim();
+      this.modelInfo = { model: this.defaultModel };
+      return { ok: true };
+    }
+    this.defaultModel = null;
+    return { ok: true };
+  }
+
+  async startAccountLogin() {
+    throw new Error("Claude CLI does not support account login.");
+  }
+
+  #handleStdout(turnId, chunk) {
+    this.buffer += chunk;
+    let newlineIndex;
+
+    while ((newlineIndex = this.buffer.indexOf("\n")) !== -1) {
+      const raw = this.buffer.slice(0, newlineIndex).trim();
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (!raw) {
+        continue;
+      }
+      let message;
+      try {
+        message = JSON.parse(raw);
+      } catch (error) {
+        this.emit("log", `Failed to parse Claude JSON: ${raw}`);
+        continue;
+      }
+      this.emit("stdout_json", { turnId, message });
+      this.#handleMessage(turnId, message);
+    }
+  }
+
+  #handleMessage(turnId, message) {
+    if (message?.type === "system" && message.subtype === "init") {
+      this.modelInfo = { model: message.model || null };
+      if (typeof message.session_id === "string" && message.session_id.trim()) {
+        const nextThreadId = message.session_id.trim();
+        this.pendingForkFromThreadId = null;
+        if (this.threadId !== nextThreadId) {
+          this.threadId = nextThreadId;
+          this.emit("ready", { threadId: this.threadId });
+        }
+      }
+      return;
+    }
+
+    if (message?.type === "assistant" && message.message?.content) {
+      const { content, id } = message.message;
+      let textBlocks = [];
+      for (const part of content) {
+        if (part?.type === "text" && typeof part.text === "string") {
+          textBlocks.push(part.text);
+        }
+        if (part?.type === "tool_use") {
+          this.toolUses.set(part.id, { name: part.name });
+        }
+      }
+      const text = textBlocks.join("");
+      if (text) {
+        this.emit("assistant_message", {
+          id: id || createTurnId(),
+          text,
+          turnId,
+        });
+      }
+      return;
+    }
+
+    if (message?.type === "user" && message.message?.content) {
+      for (const part of message.message.content) {
+        if (part?.type !== "tool_result") {
+          continue;
+        }
+        const tool = this.toolUses.get(part.tool_use_id) || {};
+        const output = typeof part.content === "string" ? part.content : "";
+        this.emit("command_execution_completed", {
+          item: {
+            id: part.tool_use_id,
+            type: "commandExecution",
+            command: tool.name || "Tool",
+            aggregatedOutput: output,
+            status: part.is_error ? "error" : "completed",
+          },
+          itemId: part.tool_use_id,
+          turnId,
+        });
+        this.toolUses.delete(part.tool_use_id);
+      }
+      return;
+    }
+
+    if (message?.type === "result") {
+      if (message.is_error) {
+        this.emit("turn_error", {
+          turnId,
+          message: message.result || "Claude returned an error.",
+        });
+      }
+    }
+  }
+
+  #logStreamChunk(prefix, bufferKey, chunk) {
+    if (!this.providerLogger) {
+      return;
+    }
+    const text = chunk == null ? "" : String(chunk);
+    this[bufferKey] += text;
+    let newlineIndex;
+    while ((newlineIndex = this[bufferKey].indexOf("\n")) !== -1) {
+      let line = this[bufferKey].slice(0, newlineIndex);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      this.providerLogger.writeLine(prefix, line);
+      this[bufferKey] = this[bufferKey].slice(newlineIndex + 1);
+    }
+  }
+
+  #flushLogBuffer(prefix, bufferKey) {
+    if (!this.providerLogger) {
+      return;
+    }
+    const leftover = this[bufferKey];
+    if (leftover) {
+      this.providerLogger.writeLine(prefix, leftover);
+      this[bufferKey] = "";
+    }
+  }
+}