workspacecord 1.0.2

package/dist/chunk-2LBNM64L.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  getConfigValue
+} from "./chunk-OKI4UVGY.js";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+function required(key) {
+  const value = getConfigValue(key);
+  if (!value) {
+    if (process.env.NODE_ENV === "test" || process.env.VITEST === "true") {
+      return `test-${key.toLowerCase()}`;
+    }
+    console.error(`ERROR: ${key} is not configured.`);
+    console.error("Run \x1B[36mworkspacecord config setup\x1B[0m to configure.");
+    process.exit(1);
+  }
+  return value;
+}
+function optional(key, fallback) {
+  return getConfigValue(key) ?? fallback;
+}
+function optionalList(key, fallback = []) {
+  const value = getConfigValue(key);
+  if (!value) return fallback;
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function optionalInt(key, fallback) {
+  const value = getConfigValue(key);
+  if (!value) return fallback;
+  const n = parseInt(value, 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+function optionalBool(key, fallback) {
+  const value = getConfigValue(key);
+  if (!value) return fallback;
+  return value === "true" || value === "1";
+}
+var config = {
+  token: required("DISCORD_TOKEN"),
+  clientId: required("DISCORD_CLIENT_ID"),
+  guildId: optional("DISCORD_GUILD_ID", ""),
+  allowedUsers: optionalList("ALLOWED_USERS"),
+  allowAllUsers: optionalBool("ALLOW_ALL_USERS", false),
+  dataDir: join(homedir(), ".workspacecord"),
+  defaultProvider: optional("DEFAULT_PROVIDER", "codex"),
+  defaultMode: optional("DEFAULT_MODE", "auto"),
+  claudePermissionMode: optional("CLAUDE_PERMISSION_MODE", "normal"),
+  maxSubagentDepth: optionalInt("MAX_SUBAGENT_DEPTH", 3),
+  maxActiveSessionsPerProject: optionalInt("MAX_ACTIVE_SESSIONS", 20),
+  autoArchiveDays: optionalInt("AUTO_ARCHIVE_DAYS", 7),
+  messageRetentionDays: optionalInt("MESSAGE_RETENTION_DAYS", 0),
+  rateLimitMs: optionalInt("RATE_LIMIT_MS", 1e3),
+  shellEnabled: optionalBool("SHELL_ENABLED", false),
+  shellAllowedUsers: optionalList("SHELL_ALLOWED_USERS"),
+  codexSandboxMode: optional("CODEX_SANDBOX_MODE", "workspace-write"),
+  codexApprovalPolicy: optional("CODEX_APPROVAL_POLICY", "on-failure"),
+  codexNetworkAccessEnabled: optionalBool("CODEX_NETWORK_ACCESS_ENABLED", false),
+  codexWebSearchMode: optional("CODEX_WEB_SEARCH", "disabled"),
+  codexReasoningEffort: optional("CODEX_REASONING_EFFORT", ""),
+  codexBaseUrl: optional("CODEX_BASE_URL", ""),
+  codexApiKey: optional("CODEX_API_KEY", ""),
+  codexPath: optional("CODEX_PATH", ""),
+  anthropicApiKey: optional("ANTHROPIC_API_KEY", ""),
+  anthropicBaseUrl: optional("ANTHROPIC_BASE_URL", ""),
+  sessionSyncIntervalMs: optionalInt("SESSION_SYNC_INTERVAL_MS", 3e4),
+  healthReportIntervalMs: optionalInt("HEALTH_REPORT_INTERVAL_MS", 6e5),
+  healthReportEnabled: optionalBool("HEALTH_REPORT_ENABLED", true),
+  healthCheckStuckThresholdMs: optionalInt("HEALTH_CHECK_STUCK_THRESHOLD_MS", 18e5),
+  healthCheckIdleThresholdMs: optionalInt("HEALTH_CHECK_IDLE_THRESHOLD_MS", 72e5)
+};
+if (config.anthropicApiKey) process.env.ANTHROPIC_API_KEY = config.anthropicApiKey;
+if (config.anthropicBaseUrl) process.env.ANTHROPIC_BASE_URL = config.anthropicBaseUrl;
+if (config.allowedUsers.length === 0 && !config.allowAllUsers) {
+  if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") {
+    console.error("ERROR: Set ALLOWED_USERS or ALLOW_ALL_USERS=true");
+    process.exit(1);
+  }
+}
+
+export {
+  config
+};

package/dist/chunk-K3NQKI34.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/chunk-NIXZJTOZ.js

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+// src/project-registry.ts
+import { randomUUID } from "crypto";
+import { resolve } from "path";
+
+// src/persistence.ts
+import { readFile, writeFile, mkdir, rename } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var dataDirOverride = null;
+function getDataDir() {
+  return dataDirOverride ?? join(homedir(), ".workspacecord");
+}
+var Store = class {
+  filename;
+  writeQueue = Promise.resolve();
+  constructor(filename) {
+    this.filename = filename;
+  }
+  get filePath() {
+    return join(getDataDir(), this.filename);
+  }
+  async read() {
+    try {
+      const data = await readFile(this.filePath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async write(data) {
+    const nextWrite = this.writeQueue.catch(() => {
+    }).then(async () => {
+      const filePath = this.filePath;
+      const dir = dirname(filePath);
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      const tmpPath = filePath + ".tmp";
+      await writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+      await rename(tmpPath, filePath);
+    });
+    this.writeQueue = nextWrite;
+    await nextWrite;
+  }
+};
+
+// src/project-registry.ts
+var store = new Store("projects.json");
+var projects = [];
+function normalizePath(path) {
+  return resolve(path);
+}
+async function saveRegistry() {
+  await store.write(projects);
+}
+async function loadRegistry() {
+  projects = await store.read() || [];
+}
+function getProjectByName(name) {
+  return projects.find((project) => project.name === name);
+}
+function getProjectByPath(path) {
+  const normalized = normalizePath(path);
+  return projects.find((project) => normalizePath(project.path) === normalized);
+}
+function getProjectByCategoryId(categoryId) {
+  return projects.find((project) => project.discordCategoryId === categoryId);
+}
+function getAllRegisteredProjects() {
+  return [...projects];
+}
+async function registerProject(name, path) {
+  const normalizedPath = normalizePath(path);
+  const existingByPath = getProjectByPath(normalizedPath);
+  if (existingByPath) {
+    if (existingByPath.name !== name) {
+      throw new Error(`Path already registered as project "${existingByPath.name}"`);
+    }
+    return existingByPath;
+  }
+  if (getProjectByName(name)) {
+    throw new Error(`Project name already exists: ${name}`);
+  }
+  const now = Date.now();
+  const project = {
+    id: randomUUID(),
+    name,
+    path: normalizedPath,
+    skills: {},
+    mcpServers: [],
+    createdAt: now,
+    updatedAt: now
+  };
+  projects.push(project);
+  await saveRegistry();
+  return project;
+}
+async function renameProject(oldName, newName) {
+  const project = getProjectByName(oldName);
+  if (!project) throw new Error(`Project not found: ${oldName}`);
+  if (oldName !== newName && getProjectByName(newName)) {
+    throw new Error(`Project name already exists: ${newName}`);
+  }
+  project.name = newName;
+  project.updatedAt = Date.now();
+  await saveRegistry();
+}
+async function removeProject(name) {
+  const before = projects.length;
+  projects = projects.filter((project) => project.name !== name);
+  if (projects.length === before) throw new Error(`Project not found: ${name}`);
+  await saveRegistry();
+}
+async function bindProjectCategory(name, categoryId, categoryName) {
+  const project = getProjectByName(name);
+  if (!project) throw new Error(`Project not found: ${name}`);
+  const existing = getProjectByCategoryId(categoryId);
+  if (existing && existing.name !== name) {
+    throw new Error(`Discord category is already bound to project "${existing.name}"`);
+  }
+  project.discordCategoryId = categoryId;
+  project.discordCategoryName = categoryName;
+  project.updatedAt = Date.now();
+  await saveRegistry();
+}
+async function unbindProjectCategory(name) {
+  const project = getProjectByName(name);
+  if (!project) throw new Error(`Project not found: ${name}`);
+  delete project.discordCategoryId;
+  delete project.discordCategoryName;
+  delete project.historyChannelId;
+  delete project.controlChannelId;
+  project.updatedAt = Date.now();
+  await saveRegistry();
+}
+async function setProjectHistoryChannel(name, historyChannelId) {
+  const project = getProjectByName(name);
+  if (!project) throw new Error(`Project not found: ${name}`);
+  project.historyChannelId = historyChannelId;
+  project.updatedAt = Date.now();
+  await saveRegistry();
+}
+async function setProjectControlChannel(name, controlChannelId) {
+  const project = getProjectByName(name);
+  if (!project) throw new Error(`Project not found: ${name}`);
+  project.controlChannelId = controlChannelId;
+  project.updatedAt = Date.now();
+  await saveRegistry();
+}
+async function updateProject(project) {
+  const index = projects.findIndex((item) => item.name === project.name);
+  if (index < 0) throw new Error(`Project not found: ${project.name}`);
+  projects[index] = { ...project, updatedAt: Date.now() };
+  await saveRegistry();
+}
+
+export {
+  Store,
+  loadRegistry,
+  getProjectByName,
+  getProjectByPath,
+  getProjectByCategoryId,
+  getAllRegisteredProjects,
+  registerProject,
+  renameProject,
+  removeProject,
+  bindProjectCategory,
+  unbindProjectCategory,
+  setProjectHistoryChannel,
+  setProjectControlChannel,
+  updateProject
+};

package/dist/chunk-OKI4UVGY.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+// src/global-config.ts
+import Configstore from "configstore";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set(["DISCORD_TOKEN", "ANTHROPIC_API_KEY", "CODEX_API_KEY"]);
+var VALID_KEYS = /* @__PURE__ */ new Set([
+  "DISCORD_TOKEN",
+  "DISCORD_CLIENT_ID",
+  "DISCORD_GUILD_ID",
+  "ALLOWED_USERS",
+  "ALLOW_ALL_USERS",
+  "DEFAULT_PROVIDER",
+  "DEFAULT_MODE",
+  "CLAUDE_PERMISSION_MODE",
+  "MAX_SUBAGENT_DEPTH",
+  "MAX_ACTIVE_SESSIONS",
+  "AUTO_ARCHIVE_DAYS",
+  "CODEX_SANDBOX_MODE",
+  "CODEX_APPROVAL_POLICY",
+  "CODEX_NETWORK_ACCESS_ENABLED",
+  "CODEX_WEB_SEARCH",
+  "CODEX_REASONING_EFFORT",
+  "CODEX_PATH",
+  "CODEX_API_KEY",
+  "CODEX_BASE_URL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_BASE_URL",
+  "MESSAGE_RETENTION_DAYS",
+  "RATE_LIMIT_MS",
+  "SHELL_ENABLED",
+  "SHELL_ALLOWED_USERS",
+  "SESSION_SYNC_INTERVAL_MS",
+  "HEALTH_REPORT_ENABLED",
+  "HEALTH_REPORT_INTERVAL_MS",
+  "HEALTH_CHECK_STUCK_THRESHOLD_MS",
+  "HEALTH_CHECK_IDLE_THRESHOLD_MS"
+]);
+var CODEX_SANDBOX_MODES = /* @__PURE__ */ new Set(["read-only", "workspace-write", "danger-full-access"]);
+var CODEX_APPROVAL_POLICIES = /* @__PURE__ */ new Set(["never", "on-request", "on-failure", "untrusted"]);
+var store = null;
+function getStore() {
+  if (!store) {
+    store = new Configstore("workspacecord", {}, { globalConfigPath: true });
+  }
+  return store;
+}
+function validateConfigValue(key, value) {
+  if (!VALID_KEYS.has(key)) {
+    return `Unknown config key: ${key}. Valid keys: ${Array.from(VALID_KEYS).join(", ")}`;
+  }
+  switch (key) {
+    case "CODEX_SANDBOX_MODE":
+      if (!CODEX_SANDBOX_MODES.has(value)) {
+        return `Invalid value for CODEX_SANDBOX_MODE. Expected one of: ${Array.from(CODEX_SANDBOX_MODES).join(", ")}`;
+      }
+      break;
+    case "CODEX_APPROVAL_POLICY":
+      if (!CODEX_APPROVAL_POLICIES.has(value)) {
+        return `Invalid value for CODEX_APPROVAL_POLICY. Expected one of: ${Array.from(CODEX_APPROVAL_POLICIES).join(", ")}`;
+      }
+      break;
+    case "ALLOW_ALL_USERS":
+      if (value !== "true" && value !== "false") {
+        return `Invalid value for ALLOW_ALL_USERS. Expected "true" or "false"`;
+      }
+      break;
+    case "SHELL_ENABLED":
+      if (value !== "true" && value !== "false") {
+        return `Invalid value for SHELL_ENABLED. Expected "true" or "false"`;
+      }
+      break;
+    case "RATE_LIMIT_MS":
+    case "SESSION_SYNC_INTERVAL_MS":
+    case "HEALTH_REPORT_INTERVAL_MS":
+    case "HEALTH_CHECK_STUCK_THRESHOLD_MS":
+    case "HEALTH_CHECK_IDLE_THRESHOLD_MS": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 0) {
+        return `Invalid value for ${key}. Expected a non-negative integer`;
+      }
+      break;
+    }
+    case "HEALTH_REPORT_ENABLED":
+      if (value !== "true" && value !== "false") {
+        return `Invalid value for HEALTH_REPORT_ENABLED. Expected "true" or "false"`;
+      }
+      break;
+    case "MAX_SUBAGENT_DEPTH":
+    case "MAX_ACTIVE_SESSIONS": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n <= 0) {
+        return `Invalid value for ${key}. Expected a positive integer`;
+      }
+      break;
+    }
+    case "MESSAGE_RETENTION_DAYS": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n <= 0) {
+        return `Invalid value for MESSAGE_RETENTION_DAYS. Expected a positive integer`;
+      }
+      break;
+    }
+    case "AUTO_ARCHIVE_DAYS": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n < 0) {
+        return `Invalid value for AUTO_ARCHIVE_DAYS. Expected a non-negative integer`;
+      }
+      break;
+    }
+    case "DEFAULT_PROVIDER":
+      if (!["claude", "codex"].includes(value)) {
+        return `Invalid value for DEFAULT_PROVIDER. Expected one of: claude, codex`;
+      }
+      break;
+    case "DEFAULT_MODE":
+      if (!["auto", "plan", "normal", "monitor"].includes(value)) {
+        return `Invalid value for DEFAULT_MODE. Expected one of: auto, plan, normal, monitor`;
+      }
+      break;
+    case "CLAUDE_PERMISSION_MODE":
+      if (!["bypass", "normal"].includes(value)) {
+        return `Invalid value for CLAUDE_PERMISSION_MODE. Expected one of: bypass, normal`;
+      }
+      break;
+    case "CODEX_WEB_SEARCH":
+      if (!["disabled", "cached", "live"].includes(value)) {
+        return `Invalid value for CODEX_WEB_SEARCH. Expected one of: disabled, cached, live`;
+      }
+      break;
+    case "CODEX_REASONING_EFFORT":
+      if (!["", "minimal", "low", "medium", "high", "xhigh"].includes(value)) {
+        return `Invalid value for CODEX_REASONING_EFFORT. Expected one of: minimal, low, medium, high, xhigh`;
+      }
+      break;
+  }
+  return null;
+}
+function maskSensitive(key, value) {
+  if (!SENSITIVE_KEYS.has(key)) return value;
+  if (value.length <= 8) return "********";
+  return `${value.slice(0, 4)}********${value.slice(-4)}`;
+}
+function readAnthropicConfig(key) {
+  const path = join(homedir(), ".claude", "settings.json");
+  try {
+    if (existsSync(path)) {
+      const content = readFileSync(path, "utf-8");
+      const config = JSON.parse(content);
+      const env = config.env || {};
+      if (key === "ANTHROPIC_API_KEY") {
+        return env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY;
+      }
+      if (key === "ANTHROPIC_BASE_URL") {
+        return env.ANTHROPIC_BASE_URL;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readCodexConfig(key) {
+  const path = join(homedir(), ".codex", "config.json");
+  try {
+    if (existsSync(path)) {
+      const content = readFileSync(path, "utf-8");
+      const config = JSON.parse(content);
+      if (key === "CODEX_API_KEY" && config.api_key) {
+        return config.api_key;
+      }
+      if (key === "CODEX_BASE_URL" && config.base_url) {
+        return config.base_url;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getConfigValue(key) {
+  const storeValue = getStore().get(key);
+  if (storeValue !== void 0) {
+    return storeValue;
+  }
+  const envValue = process.env[key];
+  if (envValue !== void 0) {
+    return envValue;
+  }
+  if (key === "ANTHROPIC_API_KEY" || key === "ANTHROPIC_BASE_URL") {
+    return readAnthropicConfig(key);
+  }
+  if (key === "CODEX_API_KEY" || key === "CODEX_BASE_URL") {
+    return readCodexConfig(key);
+  }
+  return void 0;
+}
+function setConfigValue(key, value) {
+  getStore().set(key, value);
+}
+function deleteConfigValue(key) {
+  getStore().delete(key);
+}
+function getAllConfig() {
+  return getStore().all ?? {};
+}
+function getConfigPath() {
+  return getStore().path;
+}
+
+export {
+  SENSITIVE_KEYS,
+  VALID_KEYS,
+  validateConfigValue,
+  maskSensitive,
+  getConfigValue,
+  setConfigValue,
+  deleteConfigValue,
+  getAllConfig,
+  getConfigPath
+};