@vibe80/vibe80 0.2.1 → 0.2.2

package/server/src/services/workspace.js

@@ -11,18 +11,18 @@ import storage from "../storage/index.js";
 import { generateId } from "../helpers.js";
 import { logDebug } from "../middleware/debug.js";
 
-const deploymentMode = process.env.DEPLOYMENT_MODE;
+const deploymentMode = process.env.VIBE80_DEPLOYMENT_MODE;
 const isMonoUser = deploymentMode === "mono_user";
-const workspaceHomeBase = process.env.WORKSPACE_HOME_BASE || "/home";
-const workspaceRootBase = process.env.WORKSPACE_ROOT_DIRECTORY || "/workspaces";
+const workspaceHomeBase = process.env.VIBE80_WORKSPACE_HOME_BASE || "/home";
+const workspaceRootBase = process.env.VIBE80_WORKSPACE_ROOT_DIRECTORY || "/workspaces";
 const workspaceRootName = "vibe80_workspace";
 const monoUserWorkspaceDir =
-  process.env.MONO_USER_WORKSPACE_DIR || path.join(os.homedir(), workspaceRootName);
+  process.env.VIBE80_MONO_USER_WORKSPACE_DIR || path.join(os.homedir(), workspaceRootName);
 const workspaceSessionsDirName = "sessions";
 const rootHelperPath = process.env.VIBE80_ROOT_HELPER || "/usr/local/bin/vibe80-root";
 const sudoPath = process.env.VIBE80_SUDO_PATH || "sudo";
-const workspaceUidMin = Number.parseInt(process.env.WORKSPACE_UID_MIN, 10) || 200000;
-const workspaceUidMax = Number.parseInt(process.env.WORKSPACE_UID_MAX, 10) || 999999999;
+const workspaceUidMin = Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MIN, 10) || 200000;
+const workspaceUidMax = Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MAX, 10) || 999999999;
 const workspaceUserExistsCache = new Map();
 
 export const workspaceIdPattern = isMonoUser ? /^default$/ : /^w[0-9a-f]{24}$/;
@@ -36,6 +36,36 @@ const runRootCommand = (args, options = {}) => {
   return runCommand(sudoPath, ["-n", rootHelperPath, ...args], options);
 };
 
+const runWorkspaceStatOutput = async (
+  workspaceId,
+  targetPath,
+  { gnuFormat, bsdFormat, options = {} }
+) => {
+  try {
+    return await runAsCommandOutput(
+      workspaceId,
+      "/usr/bin/stat",
+      ["-c", gnuFormat, targetPath],
+      options
+    );
+  } catch {
+    return runAsCommandOutput(
+      workspaceId,
+      "/usr/bin/stat",
+      ["-f", bsdFormat, targetPath],
+      options
+    );
+  }
+};
+
+const runHostStatOutput = async (targetPath, { gnuFormat, bsdFormat }) => {
+  try {
+    return await runCommandOutput("/usr/bin/stat", ["-c", gnuFormat, targetPath]);
+  } catch {
+    return runCommandOutput("/usr/bin/stat", ["-f", bsdFormat, targetPath]);
+  }
+};
+
 export const getWorkspacePaths = (workspaceId) => {
   const home = isMonoUser ? os.homedir() : path.join(workspaceHomeBase, workspaceId);
   const root = isMonoUser
@@ -161,34 +191,50 @@ export const listWorkspaceEntries = async (workspaceId, dirPath) => {
 };
 
 export const getWorkspaceStat = async (workspaceId, targetPath, options = {}) => {
-  const output = await runAsCommandOutput(workspaceId, "/usr/bin/stat", [
-    "-c",
-    "%f\t%s\t%a",
-    targetPath,
-  ], options);
-  const [modeHex, sizeRaw, modeRaw] = output.trim().split("\t");
-  const modeValue = Number.parseInt(modeHex, 16);
+  const output = await runWorkspaceStatOutput(workspaceId, targetPath, {
+    gnuFormat: "%f\t%s\t%a",
+    bsdFormat: "%HT\t%z\t%Lp",
+    options,
+  });
+  const [typeOrMode, sizeRaw, modeRaw] = output.trim().split("\t");
+  const modeValue = Number.parseInt(typeOrMode, 16);
   const typeBits = Number.isFinite(modeValue) ? modeValue & 0o170000 : null;
   let type = "";
-  if (typeBits === 0o100000) {
-    type = "regular";
-  } else if (typeBits === 0o040000) {
-    type = "directory";
-  } else if (typeBits === 0o120000) {
-    type = "symlink";
-  } else if (Number.isFinite(typeBits)) {
-    type = "other";
+  if (Number.isFinite(typeBits)) {
+    if (typeBits === 0o100000) {
+      type = "regular";
+    } else if (typeBits === 0o040000) {
+      type = "directory";
+    } else if (typeBits === 0o120000) {
+      type = "symlink";
+    } else {
+      type = "other";
+    }
+  } else {
+    const normalizedType = String(typeOrMode || "").toLowerCase();
+    if (normalizedType.includes("regular")) {
+      type = "regular";
+    } else if (normalizedType.includes("directory")) {
+      type = "directory";
+    } else if (normalizedType.includes("symbolic")) {
+      type = "symlink";
+    } else if (normalizedType) {
+      type = "other";
+    }
   }
   return {
     type,
     size: Number.parseInt(sizeRaw, 10),
-    mode: modeRaw,
+    mode: String(modeRaw || ""),
   };
 };
 
 export const workspacePathExists = async (workspaceId, targetPath) => {
   try {
-    await runAsCommandOutput(workspaceId, "/usr/bin/stat", ["-c", "%F", targetPath]);
+    await runWorkspaceStatOutput(workspaceId, targetPath, {
+      gnuFormat: "%F",
+      bsdFormat: "%HT",
+    });
     return true;
   } catch {
     return false;
@@ -578,11 +624,10 @@ const recoverWorkspaceIds = async (workspaceId) => {
   let gid = Number.isFinite(workspaceRecord?.gid) ? Number(workspaceRecord.gid) : null;
   if (!Number.isFinite(uid) || !Number.isFinite(gid)) {
     try {
-      const output = await runAsCommandOutput(workspaceId, "/usr/bin/stat", [
-        "-c",
-        "%u\t%g",
-        homeDir,
-      ]);
+      const output = await runWorkspaceStatOutput(workspaceId, homeDir, {
+        gnuFormat: "%u\t%g",
+        bsdFormat: "%u\t%g",
+      });
       const [uidRaw, gidRaw] = output.trim().split("\t");
       if (!Number.isFinite(uid)) {
         uid = Number(uidRaw);
@@ -592,11 +637,10 @@ const recoverWorkspaceIds = async (workspaceId) => {
       }
     } catch {
       try {
-        const output = await runCommandOutput("/usr/bin/stat", [
-        "-c",
-        "%u\t%g",
-        homeDir,
-      ]);
+        const output = await runHostStatOutput(homeDir, {
+          gnuFormat: "%u\t%g",
+          bsdFormat: "%u\t%g",
+        });
         const [uidRaw, gidRaw] = output.trim().split("\t");
         if (!Number.isFinite(uid)) {
           uid = Number(uidRaw);
@@ -843,12 +887,12 @@ const applyMonoEnabledProviders = (providers = {}, enabledConfig) => {
 };
 
 const buildMonoUserProviderOverridesFromEnv = () => {
-  const codexApiKey = readEnvValue("CODEX_API_KEY");
-  const codexAuthJsonB64Raw = process.env.CODEX_AUTH_JSON_B64;
+  const codexApiKey = readEnvValue("VIBE80_CODEX_API_KEY");
+  const codexAuthJsonB64Raw = process.env.VIBE80_CODEX_AUTH_JSON_B64;
   const hasCodexAuthJsonB64 = typeof codexAuthJsonB64Raw === "string";
   const codexAuthJsonB64 = hasCodexAuthJsonB64 ? codexAuthJsonB64Raw.trim() : "";
-  const claudeApiKey = readEnvValue("CLAUDE_API_KEY");
-  const claudeSetupTokenRaw = process.env.CLAUDE_SETUP_TOKEN;
+  const claudeApiKey = readEnvValue("VIBE80_CLAUDE_API_KEY");
+  const claudeSetupTokenRaw = process.env.VIBE80_CLAUDE_SETUP_TOKEN;
   const hasClaudeSetupToken = typeof claudeSetupTokenRaw === "string";
   const claudeSetupToken = hasClaudeSetupToken ? claudeSetupTokenRaw.trim() : "";
 
@@ -856,13 +900,13 @@ const buildMonoUserProviderOverridesFromEnv = () => {
 
   if (codexApiKey && hasCodexAuthJsonB64) {
     console.warn(
-      "[warn] Both CODEX_API_KEY and CODEX_AUTH_JSON_B64 are set; using CODEX_AUTH_JSON_B64."
+      "[warn] Both VIBE80_CODEX_API_KEY and VIBE80_CODEX_AUTH_JSON_B64 are set; using VIBE80_CODEX_AUTH_JSON_B64."
     );
   }
   if (hasCodexAuthJsonB64) {
     if (!codexAuthJsonB64) {
       console.warn(
-        "[warn] Invalid CODEX_AUTH_JSON_B64 detected; ignoring codex preprovisioning."
+        "[warn] Invalid VIBE80_CODEX_AUTH_JSON_B64 detected; ignoring codex preprovisioning."
       );
     } else {
       try {
@@ -873,7 +917,7 @@ const buildMonoUserProviderOverridesFromEnv = () => {
         };
       } catch {
         console.warn(
-          "[warn] Invalid CODEX_AUTH_JSON_B64 detected; ignoring codex preprovisioning."
+          "[warn] Invalid VIBE80_CODEX_AUTH_JSON_B64 detected; ignoring codex preprovisioning."
         );
       }
     }
@@ -885,13 +929,13 @@ const buildMonoUserProviderOverridesFromEnv = () => {
 
   if (claudeApiKey && hasClaudeSetupToken) {
     console.warn(
-      "[warn] Both CLAUDE_API_KEY and CLAUDE_SETUP_TOKEN are set; using CLAUDE_SETUP_TOKEN."
+      "[warn] Both VIBE80_CLAUDE_API_KEY and VIBE80_CLAUDE_SETUP_TOKEN are set; using VIBE80_CLAUDE_SETUP_TOKEN."
     );
   }
   if (hasClaudeSetupToken) {
     if (!claudeSetupToken) {
       console.warn(
-        "[warn] Invalid CLAUDE_SETUP_TOKEN detected; ignoring claude preprovisioning."
+        "[warn] Invalid VIBE80_CLAUDE_SETUP_TOKEN detected; ignoring claude preprovisioning."
       );
     } else {
       overrides.claude = {

package/server/src/storage/index.js

@@ -1,7 +1,7 @@
 import { createRedisStorage } from "./redis.js";
 import { createSqliteStorage } from "./sqlite.js";
 
-const backend = process.env.STORAGE_BACKEND || "sqlite";
+const backend = process.env.VIBE80_STORAGE_BACKEND || "sqlite";
 
 let storage = null;
 
@@ -10,7 +10,7 @@ if (backend === "redis") {
 } else if (backend === "sqlite") {
   storage = createSqliteStorage();
 } else {
-  throw new Error(`Unsupported STORAGE_BACKEND: ${backend}.`);
+  throw new Error(`Unsupported VIBE80_STORAGE_BACKEND: ${backend}.`);
 }
 
 export const storageBackend = backend;

package/server/src/storage/redis.js

@@ -24,11 +24,11 @@ const sanitizeSessionData = (data) => {
 };
 
 export const createRedisStorage = () => {
-  const url = process.env.REDIS_URL;
+  const url = process.env.VIBE80_REDIS_URL;
   if (!url) {
-    throw new Error("REDIS_URL is required when STORAGE_BACKEND=redis.");
+    throw new Error("VIBE80_REDIS_URL is required when VIBE80_STORAGE_BACKEND=redis.");
   }
-  const prefix = process.env.REDIS_KEY_PREFIX || DEFAULT_PREFIX;
+  const prefix = process.env.VIBE80_REDIS_KEY_PREFIX || DEFAULT_PREFIX;
   const client = createClient({ url });
 
   const sessionKey = (sessionId) => buildKey(prefix, "session", sessionId);
@@ -36,13 +36,14 @@ export const createRedisStorage = () => {
     buildKey(prefix, "session", sessionId, "worktrees");
   const workspaceSessionsKey = (workspaceId) =>
     buildKey(prefix, "workspace", workspaceId, "sessions");
-  const worktreeKey = (worktreeId) => buildKey(prefix, "worktree", worktreeId);
-  const worktreeMessagesKey = (worktreeId) =>
-    buildKey(prefix, "worktree", worktreeId, "messages");
-  const worktreeMessageIndexKey = (worktreeId) =>
-    buildKey(prefix, "worktree", worktreeId, "messageIndex");
-  const worktreeMessageSeqKey = (worktreeId) =>
-    buildKey(prefix, "worktree", worktreeId, "messageSeq");
+  const worktreeKey = (sessionId, worktreeId) =>
+    buildKey(prefix, "worktree", sessionId, worktreeId);
+  const worktreeMessagesKey = (sessionId, worktreeId) =>
+    buildKey(prefix, "worktree", sessionId, worktreeId, "messages");
+  const worktreeMessageIndexKey = (sessionId, worktreeId) =>
+    buildKey(prefix, "worktree", sessionId, worktreeId, "messageIndex");
+  const worktreeMessageSeqKey = (sessionId, worktreeId) =>
+    buildKey(prefix, "worktree", sessionId, worktreeId, "messageSeq");
   const workspaceUserIdsKey = (workspaceId) =>
     buildKey(prefix, "workspaceUserIds", workspaceId);
   const workspaceKey = (workspaceId) => buildKey(prefix, "workspace", workspaceId);
@@ -52,11 +53,12 @@ export const createRedisStorage = () => {
   const refreshTokenKey = (tokenHash) => buildKey(prefix, "refreshToken", tokenHash);
   const globalSessionsKey = () => buildKey(prefix, "sessions");
 
-  const sessionTtlMs = Number.parseInt(process.env.SESSION_MAX_TTL_MS, 10) || 0;
+  const sessionTtlMs =
+    (Number.parseInt(process.env.VIBE80_SESSION_MAX_TTL_SECONDS, 10) || 0) * 1000;
   const workspaceUidMin =
-    Number.parseInt(process.env.WORKSPACE_UID_MIN, 10) || 200000;
+    Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MIN, 10) || 200000;
   const workspaceUidMax =
-    Number.parseInt(process.env.WORKSPACE_UID_MAX, 10) || 999999999;
+    Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MAX, 10) || 999999999;
 
   const ensureConnected = async () => {
     if (client.isOpen) {
@@ -104,10 +106,10 @@ export const createRedisStorage = () => {
     const worktreeIds = await client.sMembers(sessionWorktreesKey(sessionId));
     if (worktreeIds.length) {
       const keys = worktreeIds.flatMap((id) => [
-        worktreeKey(id),
-        worktreeMessagesKey(id),
-        worktreeMessageIndexKey(id),
-        worktreeMessageSeqKey(id),
+        worktreeKey(sessionId, id),
+        worktreeMessagesKey(sessionId, id),
+        worktreeMessageIndexKey(sessionId, id),
+        worktreeMessageSeqKey(sessionId, id),
       ]);
       await client.del(keys);
     }
@@ -143,24 +145,24 @@ export const createRedisStorage = () => {
 
   const saveWorktree = async (sessionId, worktreeId, data) => {
     await ensureConnected();
-    await setWithTtl(worktreeKey(worktreeId), toJson(data), sessionTtlMs);
+    await setWithTtl(worktreeKey(sessionId, worktreeId), toJson(data), sessionTtlMs);
     await client.sAdd(sessionWorktreesKey(sessionId), worktreeId);
     await touchTtl(sessionWorktreesKey(sessionId), sessionTtlMs);
   };
 
-  const getWorktree = async (worktreeId) => {
+  const getWorktree = async (sessionId, worktreeId) => {
     await ensureConnected();
-    const raw = await client.get(worktreeKey(worktreeId));
+    const raw = await client.get(worktreeKey(sessionId, worktreeId));
     return fromJson(raw);
   };
 
   const deleteWorktree = async (sessionId, worktreeId) => {
     await ensureConnected();
     await client.del(
-      worktreeKey(worktreeId),
-      worktreeMessagesKey(worktreeId),
-      worktreeMessageIndexKey(worktreeId),
-      worktreeMessageSeqKey(worktreeId)
+      worktreeKey(sessionId, worktreeId),
+      worktreeMessagesKey(sessionId, worktreeId),
+      worktreeMessageIndexKey(sessionId, worktreeId),
+      worktreeMessageSeqKey(sessionId, worktreeId)
     );
     await client.sRem(sessionWorktreesKey(sessionId), worktreeId);
   };
@@ -171,7 +173,7 @@ export const createRedisStorage = () => {
     if (!ids.length) {
       return [];
     }
-    const keys = ids.map((id) => worktreeKey(id));
+    const keys = ids.map((id) => worktreeKey(sessionId, id));
     const raw = await client.mGet(keys);
     return raw.map(fromJson).filter(Boolean);
   };
@@ -182,12 +184,12 @@ export const createRedisStorage = () => {
     if (!messageId) {
       throw new Error("Message id is required.");
     }
-    const seq = await client.incr(worktreeMessageSeqKey(worktreeId));
-    await client.hSet(worktreeMessageIndexKey(worktreeId), messageId, seq);
-    await client.rPush(worktreeMessagesKey(worktreeId), toJson(message));
-    await touchTtl(worktreeMessagesKey(worktreeId), sessionTtlMs);
-    await touchTtl(worktreeMessageIndexKey(worktreeId), sessionTtlMs);
-    await touchTtl(worktreeMessageSeqKey(worktreeId), sessionTtlMs);
+    const seq = await client.incr(worktreeMessageSeqKey(sessionId, worktreeId));
+    await client.hSet(worktreeMessageIndexKey(sessionId, worktreeId), messageId, seq);
+    await client.rPush(worktreeMessagesKey(sessionId, worktreeId), toJson(message));
+    await touchTtl(worktreeMessagesKey(sessionId, worktreeId), sessionTtlMs);
+    await touchTtl(worktreeMessageIndexKey(sessionId, worktreeId), sessionTtlMs);
+    await touchTtl(worktreeMessageSeqKey(sessionId, worktreeId), sessionTtlMs);
   };
 
   const getWorktreeMessages = async (
@@ -196,7 +198,7 @@ export const createRedisStorage = () => {
     { limit = null, beforeMessageId = null } = {}
   ) => {
     await ensureConnected();
-    const listKey = worktreeMessagesKey(worktreeId);
+    const listKey = worktreeMessagesKey(sessionId, worktreeId);
     const listLength = await client.lLen(listKey);
     if (!listLength) {
       return [];
@@ -207,7 +209,7 @@ export const createRedisStorage = () => {
 
     if (beforeMessageId) {
       const seqValue = await client.hGet(
-        worktreeMessageIndexKey(worktreeId),
+        worktreeMessageIndexKey(sessionId, worktreeId),
         beforeMessageId
       );
       const seq = Number.parseInt(seqValue, 10);
@@ -233,9 +235,9 @@ export const createRedisStorage = () => {
   const clearWorktreeMessages = async (sessionId, worktreeId) => {
     await ensureConnected();
     await client.del(
-      worktreeMessagesKey(worktreeId),
-      worktreeMessageIndexKey(worktreeId),
-      worktreeMessageSeqKey(worktreeId)
+      worktreeMessagesKey(sessionId, worktreeId),
+      worktreeMessageIndexKey(sessionId, worktreeId),
+      worktreeMessageSeqKey(sessionId, worktreeId)
     );
   };
 

package/server/src/storage/sqlite.js

@@ -72,12 +72,12 @@ const all = (db, sql, params = []) =>
 
 export const createSqliteStorage = () => {
   const homeDir = process.env.HOME || os.homedir();
-  const isMonoUser = process.env.DEPLOYMENT_MODE === "mono_user";
+  const isMonoUser = process.env.VIBE80_DEPLOYMENT_MODE === "mono_user";
   const defaultDataDirectory = isMonoUser
     ? path.join(homeDir, ".vibe80")
     : "/var/lib/vibe80";
   const dataDirectory = process.env.VIBE80_DATA_DIRECTORY || defaultDataDirectory;
-  const dbPath = process.env.SQLITE_PATH || path.join(dataDirectory, "base.sqlite");
+  const dbPath = process.env.VIBE80_SQLITE_PATH || path.join(dataDirectory, "base.sqlite");
   const resolvedPath = path.resolve(dbPath);
   const dir = path.dirname(resolvedPath);
   fs.mkdirSync(dir, { recursive: true, mode: 0o750 });
@@ -108,9 +108,10 @@ export const createSqliteStorage = () => {
     await run(
       db,
       `CREATE TABLE IF NOT EXISTS worktrees (
-        worktreeId TEXT PRIMARY KEY,
+        worktreeId TEXT NOT NULL,
         sessionId TEXT NOT NULL,
         data TEXT NOT NULL,
+        PRIMARY KEY (sessionId, worktreeId),
         FOREIGN KEY(sessionId) REFERENCES sessions(sessionId) ON DELETE CASCADE
       );`
     );
@@ -127,7 +128,7 @@ export const createSqliteStorage = () => {
         worktreeId TEXT NOT NULL,
         createdAt INTEGER NOT NULL,
         data TEXT NOT NULL,
-        PRIMARY KEY (worktreeId, messageId),
+        PRIMARY KEY (sessionId, worktreeId, messageId),
         FOREIGN KEY(sessionId) REFERENCES sessions(sessionId) ON DELETE CASCADE
       );`
     );
@@ -194,7 +195,7 @@ export const createSqliteStorage = () => {
     const row = await get(db, "SELECT lastUid FROM workspace_uid_seq WHERE id = 1");
     if (!row) {
       const workspaceUidMin =
-        Number.parseInt(process.env.WORKSPACE_UID_MIN, 10) || 200000;
+        Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MIN, 10) || 200000;
       await run(
         db,
         "INSERT INTO workspace_uid_seq (id, lastUid) VALUES (1, ?)",
@@ -275,19 +276,18 @@ export const createSqliteStorage = () => {
       db,
       `INSERT INTO worktrees (worktreeId, sessionId, data)
        VALUES (?, ?, ?)
-       ON CONFLICT(worktreeId) DO UPDATE SET
-         sessionId=excluded.sessionId,
+       ON CONFLICT(sessionId, worktreeId) DO UPDATE SET
          data=excluded.data;`,
       [worktreeId, sessionId, toJson(data)]
     );
   };
 
-  const getWorktree = async (worktreeId) => {
+  const getWorktree = async (sessionId, worktreeId) => {
     await ensureConnected();
     const row = await get(
       db,
-      "SELECT data FROM worktrees WHERE worktreeId = ?",
-      [worktreeId]
+      "SELECT data FROM worktrees WHERE sessionId = ? AND worktreeId = ?",
+      [sessionId, worktreeId]
     );
     return fromJson(row?.data);
   };
@@ -328,7 +328,7 @@ export const createSqliteStorage = () => {
       db,
       `INSERT INTO worktree_messages (messageId, sessionId, worktreeId, createdAt, data)
        VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(worktreeId, messageId) DO NOTHING;`,
+       ON CONFLICT(sessionId, worktreeId, messageId) DO NOTHING;`,
       [messageId, sessionId, worktreeId, createdAt, toJson(message)]
     );
   };
@@ -559,9 +559,9 @@ export const createSqliteStorage = () => {
   const getNextWorkspaceUid = async () => {
     await ensureConnected();
     const workspaceUidMin =
-      Number.parseInt(process.env.WORKSPACE_UID_MIN, 10) || 200000;
+      Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MIN, 10) || 200000;
     const workspaceUidMax =
-      Number.parseInt(process.env.WORKSPACE_UID_MAX, 10) || 999999999;
+      Number.parseInt(process.env.VIBE80_WORKSPACE_UID_MAX, 10) || 999999999;
     await run(db, "BEGIN IMMEDIATE");
     try {
       const row = await get(db, "SELECT lastUid FROM workspace_uid_seq WHERE id = 1");