@runtimescope/collector 0.9.3 → 0.10.0

package/dist/{chunk-MM44DN7Y.js → chunk-WWFIEANS.js}

@@ -929,7 +929,7 @@ var CollectorServer = class {
     this.disconnectCallbacks.push(cb);
   }
   start(options = {}) {
-    const port = options.port ?? 9090;
+    const port = options.port ?? 6767;
     const host = options.host ?? "127.0.0.1";
     const maxRetries = options.maxRetries ?? 5;
     const retryDelayMs = options.retryDelayMs ?? 1e3;
@@ -1090,7 +1090,15 @@ var CollectorServer = class {
     switch (msg.type) {
       case "handshake": {
         const payload = msg.payload;
-        if (this.authManager?.isEnabled()) {
+        let workspaceFromKey = null;
+        if (payload.authToken && this.pmStore?.getWorkspaceByApiKey) {
+          try {
+            const ws2 = this.pmStore.getWorkspaceByApiKey(payload.authToken);
+            if (ws2) workspaceFromKey = { id: ws2.id, slug: ws2.slug };
+          } catch {
+          }
+        }
+        if (this.authManager?.isEnabled() && !workspaceFromKey) {
           if (!this.authManager.isAuthorized(payload.authToken)) {
             try {
               ws.send(JSON.stringify({
@@ -1103,15 +1111,27 @@ var CollectorServer = class {
             ws.close(4001, "Authentication failed");
             return;
           }
-          this.pendingHandshakes.delete(ws);
         }
+        this.pendingHandshakes.delete(ws);
         const projectName = payload.appName;
         const projectId = payload.projectId ?? (this.projectManager ? resolveProjectId(this.projectManager, projectName, this.pmStore) : void 0);
         this.clients.set(ws, {
           sessionId: payload.sessionId,
           projectName,
-          projectId
+          projectId,
+          workspaceId: workspaceFromKey?.id
         });
+        if (workspaceFromKey && projectId && this.pmStore?.listProjects && this.pmStore.setProjectWorkspace) {
+          try {
+            const existing = this.pmStore.listProjects().find(
+              (p) => p.runtimeProjectId === projectId
+            );
+            if (existing && !existing.workspaceId) {
+              this.pmStore.setProjectWorkspace(existing.id, workspaceFromKey.id);
+            }
+          } catch {
+          }
+        }
         const sqliteStore = this.ensureSqliteStore(projectName);
         if (sqliteStore) {
           const sessionInfo = {
@@ -1273,9 +1293,9 @@ import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync as
 import { join } from "path";
 import { homedir } from "os";
 var DEFAULT_GLOBAL_CONFIG = {
-  defaultPort: 9090,
+  defaultPort: 6767,
   bufferSize: 1e4,
-  httpPort: 9091
+  httpPort: 6768
 };
 var ProjectManager = class {
   baseDir;
@@ -1547,7 +1567,7 @@ function scaffoldProjectConfig(projectDir, opts) {
     return existing;
   }
   const projectId = generateProjectId();
-  const httpPort = process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091";
+  const httpPort = process.env.RUNTIMESCOPE_HTTP_PORT ?? "6768";
   const dsn = `runtimescope://${projectId}@localhost:${httpPort}/${opts.appName}`;
   const config = {
     projectId,
@@ -2156,7 +2176,11 @@ function createPmRouter(pmStore, discovery, helpers, broadcastDevServer) {
       helpers.json(res, { ...project, stats });
       return;
     }
-    const projects = pmStore.listProjects();
+    let projects = pmStore.listProjects();
+    const workspaceId = params.get("workspace_id");
+    if (workspaceId) {
+      projects = projects.filter((p) => p.workspaceId === workspaceId);
+    }
     helpers.json(res, { data: projects, count: projects.length });
   });
   route("GET", "/api/pm/projects/export-csv", (_req, res, params) => {
@@ -2264,6 +2288,142 @@ function createPmRouter(pmStore, discovery, helpers, broadcastDevServer) {
     pmStore.deleteProject(id);
     helpers.json(res, { ok: true, deleted: project.name });
   });
+  route("PUT", "/api/pm/projects/:id/workspace", async (req, res, params) => {
+    const id = params.get("id");
+    const body = await helpers.readBody(req, 4096);
+    if (!body) {
+      helpers.json(res, { error: "Missing body" }, 400);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      helpers.json(res, { error: "Invalid JSON" }, 400);
+      return;
+    }
+    if (!parsed.workspace_id) {
+      helpers.json(res, { error: "Missing workspace_id" }, 400);
+      return;
+    }
+    try {
+      pmStore.setProjectWorkspace(id, parsed.workspace_id);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("GET", "/api/pm/workspaces", (_req, res) => {
+    helpers.json(res, { data: pmStore.listWorkspaces() });
+  });
+  route("POST", "/api/pm/workspaces", async (req, res) => {
+    const body = await helpers.readBody(req, 4096);
+    if (!body) {
+      helpers.json(res, { error: "Missing body" }, 400);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      helpers.json(res, { error: "Invalid JSON" }, 400);
+      return;
+    }
+    if (!parsed.name || typeof parsed.name !== "string") {
+      helpers.json(res, { error: "Missing name" }, 400);
+      return;
+    }
+    try {
+      const ws = pmStore.createWorkspace({ name: parsed.name, slug: parsed.slug, description: parsed.description });
+      helpers.json(res, ws, 201);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("GET", "/api/pm/workspaces/:id", (_req, res, params) => {
+    const id = params.get("id");
+    const ws = pmStore.getWorkspace(id);
+    if (!ws) {
+      helpers.json(res, { error: "Workspace not found" }, 404);
+      return;
+    }
+    helpers.json(res, ws);
+  });
+  route("PUT", "/api/pm/workspaces/:id", async (req, res, params) => {
+    const id = params.get("id");
+    if (!pmStore.getWorkspace(id)) {
+      helpers.json(res, { error: "Workspace not found" }, 404);
+      return;
+    }
+    const body = await helpers.readBody(req, 4096);
+    if (!body) {
+      helpers.json(res, { error: "Missing body" }, 400);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      helpers.json(res, { error: "Invalid JSON" }, 400);
+      return;
+    }
+    try {
+      pmStore.updateWorkspace(id, parsed);
+      helpers.json(res, pmStore.getWorkspace(id));
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("DELETE", "/api/pm/workspaces/:id", (_req, res, params) => {
+    const id = params.get("id");
+    try {
+      pmStore.deleteWorkspace(id);
+      helpers.json(res, { ok: true });
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("GET", "/api/pm/workspaces/:id/api-keys", (_req, res, params) => {
+    const id = params.get("id");
+    if (!pmStore.getWorkspace(id)) {
+      helpers.json(res, { error: "Workspace not found" }, 404);
+      return;
+    }
+    helpers.json(res, { data: pmStore.listApiKeys(id) });
+  });
+  route("POST", "/api/pm/workspaces/:id/api-keys", async (req, res, params) => {
+    const id = params.get("id");
+    if (!pmStore.getWorkspace(id)) {
+      helpers.json(res, { error: "Workspace not found" }, 404);
+      return;
+    }
+    const body = await helpers.readBody(req, 4096);
+    if (!body) {
+      helpers.json(res, { error: "Missing body" }, 400);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      helpers.json(res, { error: "Invalid JSON" }, 400);
+      return;
+    }
+    if (!parsed.label) {
+      helpers.json(res, { error: "Missing label" }, 400);
+      return;
+    }
+    try {
+      const key = pmStore.createApiKey(id, parsed.label, parsed.expires_at);
+      helpers.json(res, key, 201);
+    } catch (err) {
+      helpers.json(res, { error: err.message }, 400);
+    }
+  });
+  route("DELETE", "/api/pm/api-keys/:key", (_req, res, params) => {
+    pmStore.revokeApiKey(params.get("key"));
+    helpers.json(res, { ok: true });
+  });
   route("GET", "/api/pm/tasks", (_req, res, params) => {
     const projectId = params.get("project_id") ?? void 0;
     const status = params.get("status") ?? void 0;
@@ -3164,6 +3324,16 @@ async function readRuleFile(filePath) {
 }
 
 // src/http-server.ts
+var COLLECTOR_VERSION = (() => {
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgJson = readFileSync4(resolve(here, "..", "package.json"), "utf-8");
+    const pkg = JSON.parse(pkgJson);
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
 var HttpServer = class {
   server = null;
   wss = null;
@@ -3177,7 +3347,7 @@ var HttpServer = class {
   routes = /* @__PURE__ */ new Map();
   pmRouter = null;
   sdkBundlePath = null;
-  activePort = 9091;
+  activePort = 6768;
   startedAt = Date.now();
   connectedSessionsGetter = null;
   pmStore = null;
@@ -3203,6 +3373,7 @@ var HttpServer = class {
     this.routes.set("GET /api/health", (_req, res) => {
       this.json(res, {
         status: "ok",
+        version: COLLECTOR_VERSION,
         timestamp: Date.now(),
         uptime: Math.floor((Date.now() - this.startedAt) / 1e3),
         sessions: this.store.getSessionInfo().filter((s) => s.isConnected).length,
@@ -3426,6 +3597,21 @@ var HttpServer = class {
           } catch {
           }
         }
+        if (this.pmStore) {
+          try {
+            const token = AuthManager.extractBearer(req.headers.authorization);
+            if (token) {
+              const ws = this.pmStore.getWorkspaceByApiKey(token);
+              if (ws && projectId) {
+                const existing = this.pmStore.listProjects().find((p) => p.runtimeProjectId === projectId);
+                if (existing && !existing.workspaceId) {
+                  this.pmStore.setProjectWorkspace(existing.id, ws.id);
+                }
+              }
+            }
+          } catch {
+          }
+        }
       }
       const VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
         "network",
@@ -3492,7 +3678,7 @@ var HttpServer = class {
     return null;
   }
   async start(options = {}) {
-    const basePort = options.port ?? parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091", 10);
+    const basePort = options.port ?? parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "6768", 10);
     const host = options.host ?? "127.0.0.1";
     const tls = options.tls;
     const maxRetries = 5;
@@ -3624,7 +3810,9 @@ var HttpServer = class {
     const isPublic = url.pathname === "/api/health" || url.pathname === "/runtimescope.js" || url.pathname === "/snippet";
     if (!isPublic && this.authManager?.isEnabled()) {
       const token = AuthManager.extractBearer(req.headers.authorization);
-      if (!this.authManager.isAuthorized(token)) {
+      const isGlobal = this.authManager.isAuthorized(token);
+      const isWorkspaceToken = !!(token && this.pmStore?.getWorkspaceByApiKey(token));
+      if (!isGlobal && !isWorkspaceToken) {
         this.json(res, { error: "Unauthorized", code: "AUTH_FAILED" }, 401);
         return;
       }
@@ -3756,6 +3944,7 @@ function numParam(params, key) {
 
 // src/pm/pm-store.ts
 import Database from "better-sqlite3";
+import { randomBytes as randomBytes3 } from "crypto";
 var PmStore = class {
   db;
   constructor(options) {
@@ -3888,6 +4077,30 @@ var PmStore = class {
         deleted_at INTEGER NOT NULL
       );
       CREATE INDEX IF NOT EXISTS idx_deleted_path ON pm_deleted_projects(path);
+
+      -- Multi-tenant workspaces (Phase 1) --
+      CREATE TABLE IF NOT EXISTS pm_workspaces (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        slug TEXT UNIQUE NOT NULL,
+        description TEXT,
+        is_default INTEGER NOT NULL DEFAULT 0,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_workspaces_slug ON pm_workspaces(slug);
+
+      CREATE TABLE IF NOT EXISTS pm_api_keys (
+        key TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL,
+        label TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        last_used_at INTEGER,
+        expires_at INTEGER,
+        revoked_at INTEGER,
+        FOREIGN KEY (workspace_id) REFERENCES pm_workspaces(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_api_keys_workspace ON pm_api_keys(workspace_id);
     `);
   }
   runMigrations() {
@@ -3907,18 +4120,45 @@ var PmStore = class {
       this.db.exec("ALTER TABLE pm_projects ADD COLUMN runtime_project_id TEXT DEFAULT NULL");
     } catch {
     }
+    try {
+      this.db.exec("ALTER TABLE pm_projects ADD COLUMN workspace_id TEXT DEFAULT NULL");
+    } catch {
+    }
+    this.ensureDefaultWorkspace();
+  }
+  /**
+   * Ensure a default "personal" workspace exists and every project has a
+   * workspace_id. Runs on every startup — idempotent.
+   */
+  ensureDefaultWorkspace() {
+    const existing = this.db.prepare("SELECT id FROM pm_workspaces WHERE is_default = 1").get();
+    let defaultId;
+    if (existing) {
+      defaultId = existing.id;
+    } else {
+      defaultId = generateWorkspaceId();
+      const now = Date.now();
+      this.db.prepare(
+        `INSERT INTO pm_workspaces (id, name, slug, description, is_default, created_at, updated_at)
+           VALUES (?, ?, ?, ?, 1, ?, ?)`
+      ).run(defaultId, "Personal", "personal", "Your personal workspace", now, now);
+    }
+    this.db.prepare("UPDATE pm_projects SET workspace_id = ? WHERE workspace_id IS NULL").run(defaultId);
   }
   // ============================================================
   // Projects
   // ============================================================
   upsertProject(project) {
+    const workspaceId = project.workspaceId ?? this.db.prepare("SELECT id FROM pm_workspaces WHERE is_default = 1 LIMIT 1").get();
+    const resolvedWorkspaceId = typeof workspaceId === "string" ? workspaceId : workspaceId?.id ?? null;
     this.db.prepare(`
-      INSERT INTO pm_projects (id, name, path, claude_project_key, runtimescope_project,
+      INSERT INTO pm_projects (id, workspace_id, name, path, claude_project_key, runtimescope_project,
         phase, management_authorized, probable_to_complete, project_status,
         category, sdk_installed, runtime_apps,
         created_at, updated_at, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
+        workspace_id = COALESCE(pm_projects.workspace_id, excluded.workspace_id),
         name = excluded.name,
         path = COALESCE(excluded.path, pm_projects.path),
         claude_project_key = COALESCE(excluded.claude_project_key, pm_projects.claude_project_key),
@@ -3929,6 +4169,7 @@ var PmStore = class {
         metadata = COALESCE(excluded.metadata, pm_projects.metadata)
     `).run(
       project.id,
+      resolvedWorkspaceId,
       project.name,
       project.path ?? null,
       project.claudeProjectKey ?? null,
@@ -4064,9 +4305,123 @@ var PmStore = class {
     const rows = this.db.prepare("SELECT DISTINCT category FROM pm_projects WHERE category IS NOT NULL ORDER BY category ASC").all();
     return rows.map((r) => r.category);
   }
+  // ============================================================
+  // Workspaces (multi-tenant)
+  // ============================================================
+  listWorkspaces() {
+    const rows = this.db.prepare("SELECT * FROM pm_workspaces ORDER BY is_default DESC, name ASC").all();
+    return rows.map(mapWorkspaceRow);
+  }
+  getWorkspace(id) {
+    const row = this.db.prepare("SELECT * FROM pm_workspaces WHERE id = ?").get(id);
+    return row ? mapWorkspaceRow(row) : null;
+  }
+  getWorkspaceBySlug(slug) {
+    const row = this.db.prepare("SELECT * FROM pm_workspaces WHERE slug = ?").get(slug);
+    return row ? mapWorkspaceRow(row) : null;
+  }
+  getDefaultWorkspace() {
+    const row = this.db.prepare("SELECT * FROM pm_workspaces WHERE is_default = 1 LIMIT 1").get();
+    if (!row) {
+      throw new Error("Default workspace missing \u2014 ensureDefaultWorkspace() must run first");
+    }
+    return mapWorkspaceRow(row);
+  }
+  createWorkspace(input) {
+    const id = generateWorkspaceId();
+    const slug = (input.slug ?? input.name).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    if (!slug) {
+      throw new Error("Workspace slug cannot be empty");
+    }
+    if (this.getWorkspaceBySlug(slug)) {
+      throw new Error(`Workspace with slug "${slug}" already exists`);
+    }
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT INTO pm_workspaces (id, name, slug, description, is_default, created_at, updated_at)
+         VALUES (?, ?, ?, ?, 0, ?, ?)`
+    ).run(id, input.name, slug, input.description ?? null, now, now);
+    return { id, name: input.name, slug, description: input.description, createdAt: now, updatedAt: now, isDefault: false };
+  }
+  updateWorkspace(id, updates) {
+    const sets = [];
+    const params = [];
+    if (updates.name !== void 0) {
+      sets.push("name = ?");
+      params.push(updates.name);
+    }
+    if (updates.slug !== void 0) {
+      sets.push("slug = ?");
+      params.push(updates.slug);
+    }
+    if (updates.description !== void 0) {
+      sets.push("description = ?");
+      params.push(updates.description);
+    }
+    if (!sets.length) return;
+    sets.push("updated_at = ?");
+    params.push(Date.now());
+    params.push(id);
+    this.db.prepare(`UPDATE pm_workspaces SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+  }
+  deleteWorkspace(id) {
+    const ws = this.getWorkspace(id);
+    if (!ws) return;
+    if (ws.isDefault) {
+      throw new Error("Cannot delete the default workspace");
+    }
+    const def = this.getDefaultWorkspace();
+    this.db.prepare("UPDATE pm_projects SET workspace_id = ? WHERE workspace_id = ?").run(def.id, id);
+    this.db.prepare("DELETE FROM pm_api_keys WHERE workspace_id = ?").run(id);
+    this.db.prepare("DELETE FROM pm_workspaces WHERE id = ?").run(id);
+  }
+  /** Move a project between workspaces. */
+  setProjectWorkspace(projectId, workspaceId) {
+    const ws = this.getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace ${workspaceId} does not exist`);
+    this.db.prepare("UPDATE pm_projects SET workspace_id = ?, updated_at = ? WHERE id = ?").run(workspaceId, Date.now(), projectId);
+  }
+  // ============================================================
+  // API Keys (workspace-scoped)
+  // ============================================================
+  createApiKey(workspaceId, label, expiresAt) {
+    const ws = this.getWorkspace(workspaceId);
+    if (!ws) throw new Error(`Workspace ${workspaceId} does not exist`);
+    const key = `tk_${randomBytes3(24).toString("hex")}`;
+    const now = Date.now();
+    this.db.prepare(
+      `INSERT INTO pm_api_keys (key, workspace_id, label, created_at, expires_at)
+         VALUES (?, ?, ?, ?, ?)`
+    ).run(key, workspaceId, label, now, expiresAt ?? null);
+    return { key, workspaceId, label, createdAt: now, expiresAt };
+  }
+  listApiKeys(workspaceId) {
+    const rows = this.db.prepare(
+      `SELECT * FROM pm_api_keys WHERE workspace_id = ? AND revoked_at IS NULL ORDER BY created_at DESC`
+    ).all(workspaceId);
+    return rows.map(mapApiKeyRow);
+  }
+  revokeApiKey(key) {
+    this.db.prepare("UPDATE pm_api_keys SET revoked_at = ? WHERE key = ?").run(Date.now(), key);
+  }
+  getWorkspaceByApiKey(key) {
+    const row = this.db.prepare(
+      `SELECT w.* FROM pm_api_keys k
+         JOIN pm_workspaces w ON w.id = k.workspace_id
+         WHERE k.key = ? AND k.revoked_at IS NULL
+         AND (k.expires_at IS NULL OR k.expires_at > ?)`
+    ).get(key, Date.now());
+    if (!row) return null;
+    try {
+      this.db.prepare("UPDATE pm_api_keys SET last_used_at = ? WHERE key = ?").run(Date.now(), key);
+    } catch {
+    }
+    return mapWorkspaceRow(row);
+  }
   mapProjectRow(row) {
     return {
       id: row.id,
+      workspaceId: row.workspace_id ?? void 0,
       name: row.name,
       path: row.path ?? void 0,
       claudeProjectKey: row.claude_project_key ?? void 0,
@@ -4857,6 +5212,31 @@ var PmStore = class {
     this.db.close();
   }
 };
+function generateWorkspaceId() {
+  return `ws_${randomBytes3(8).toString("hex")}`;
+}
+function mapWorkspaceRow(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description ?? void 0,
+    isDefault: row.is_default === 1,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function mapApiKeyRow(row) {
+  return {
+    key: row.key,
+    workspaceId: row.workspace_id,
+    label: row.label,
+    createdAt: row.created_at,
+    lastUsedAt: row.last_used_at ?? void 0,
+    expiresAt: row.expires_at ?? void 0,
+    revokedAt: row.revoked_at ?? void 0
+  };
+}
 
 // src/pm/session-parser.ts
 import { createReadStream } from "fs";
@@ -5665,4 +6045,4 @@ export {
   parseSessionJsonl,
   ProjectDiscovery
 };
-//# sourceMappingURL=chunk-MM44DN7Y.js.map
+//# sourceMappingURL=chunk-WWFIEANS.js.map