workspacecord 1.0.2 → 1.1.0

package/dist/chunk-PUKMHDXS.js

@@ -0,0 +1,196 @@
+#!/usr/bin/env node
+import {
+  endSession,
+  getAllSessions,
+  getProject,
+  setHistoryChannelId
+} from "./chunk-IFSOU4XI.js";
+import {
+  config
+} from "./chunk-D6J3X35H.js";
+import {
+  Store
+} from "./chunk-CBNENUW6.js";
+
+// src/archive-manager.ts
+import { ChannelType, EmbedBuilder } from "discord.js";
+var archiveStore = new Store("archived.json");
+var archived = [];
+async function loadArchived() {
+  archived = await archiveStore.read() || [];
+}
+async function saveArchived() {
+  await archiveStore.write(archived);
+}
+function getArchivedSessions(categoryId) {
+  return archived.filter((a) => a.categoryId === categoryId);
+}
+function isArchivedProviderSession(provider, providerSessionId) {
+  if (!providerSessionId) return false;
+  return archived.some(
+    (record) => record.provider === provider && record.providerSessionId === providerSessionId
+  );
+}
+async function ensureHistoryChannel(guild, categoryId) {
+  const project = getProject(categoryId);
+  if (!project) return null;
+  if (project.historyChannelId) {
+    const existing2 = guild.channels.cache.get(project.historyChannelId);
+    if (existing2?.type === ChannelType.GuildForum) {
+      return existing2;
+    }
+  }
+  const existing = guild.channels.cache.find(
+    (ch) => ch.parentId === categoryId && ch.name === "history" && ch.type === ChannelType.GuildForum
+  );
+  if (existing?.type === ChannelType.GuildForum) {
+    setHistoryChannelId(categoryId, existing.id);
+    return existing;
+  }
+  try {
+    const forum = await guild.channels.create({
+      name: "history",
+      type: ChannelType.GuildForum,
+      parent: categoryId,
+      topic: "Archived agent sessions for this project",
+      reason: "Auto-created by workspacecord for session archiving"
+    });
+    setHistoryChannelId(categoryId, forum.id);
+    return forum;
+  } catch (err) {
+    console.error(`[archive-manager] Failed to create #history forum: ${err.message}`);
+    return null;
+  }
+}
+async function archiveSession(session, guild, summary) {
+  const historyForum = await ensureHistoryChannel(guild, session.categoryId);
+  const record = {
+    id: session.id,
+    categoryId: session.categoryId,
+    agentLabel: session.agentLabel,
+    provider: session.provider,
+    providerSessionId: session.providerSessionId,
+    directory: session.directory,
+    mode: session.mode,
+    createdAt: session.createdAt,
+    archivedAt: Date.now(),
+    messageCount: session.messageCount,
+    totalCost: session.totalCost,
+    summary: summary || session.workflowState.lastWorkerSummary
+  };
+  if (historyForum) {
+    try {
+      const date = new Date(session.createdAt).toISOString().slice(0, 10);
+      const postName = `[${session.provider}] ${session.agentLabel} \xB7 ${date}`.slice(0, 100);
+      const embed = new EmbedBuilder().setColor(9807270).setTitle(`Archived: ${session.agentLabel}`).addFields(
+        { name: "Provider", value: session.provider, inline: true },
+        { name: "Mode", value: session.mode, inline: true },
+        { name: "Messages", value: `${session.messageCount}`, inline: true },
+        { name: "Directory", value: `\`${session.directory}\``, inline: false },
+        {
+          name: "Active",
+          value: `${formatDuration(record.archivedAt - record.createdAt)}`,
+          inline: true
+        },
+        {
+          name: "Cost",
+          value: session.totalCost > 0 ? `$${session.totalCost.toFixed(4)}` : "N/A",
+          inline: true
+        }
+      );
+      if (record.summary) {
+        embed.addFields({ name: "Last Summary", value: record.summary.slice(0, 1e3) });
+      }
+      const post = await historyForum.threads.create({
+        name: postName,
+        message: { embeds: [embed] },
+        reason: `Session archived by workspacecord`
+      });
+      record.forumPostId = post.id;
+    } catch (err) {
+      console.error(`[archive-manager] Failed to create forum post: ${err.message}`);
+    }
+  }
+  if (session.type === "persistent") {
+    try {
+      const channel = guild.channels.cache.get(session.channelId);
+      if (channel) {
+        await channel.delete(`Session archived by workspacecord`);
+      }
+    } catch (err) {
+      console.error(
+        `[archive-manager] Failed to delete session channel: ${err.message}`
+      );
+    }
+  }
+  try {
+    await endSession(session.id);
+  } catch {
+  }
+  archived.push(record);
+  await saveArchived();
+  return record;
+}
+async function checkAutoArchive(guild) {
+  if (!config.autoArchiveDays && !config.maxActiveSessionsPerProject) return;
+  const now = Date.now();
+  const inactiveThreshold = config.autoArchiveDays ? config.autoArchiveDays * 24 * 60 * 60 * 1e3 : 0;
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const session of getAllSessions()) {
+    if (session.type !== "persistent") continue;
+    if (session.isGenerating) continue;
+    const list = byCategory.get(session.categoryId) ?? [];
+    list.push(session);
+    byCategory.set(session.categoryId, list);
+  }
+  for (const [categoryId, categorySessions] of byCategory) {
+    const toArchive = /* @__PURE__ */ new Set();
+    if (inactiveThreshold > 0) {
+      for (const s of categorySessions) {
+        if (now - s.lastActivity > inactiveThreshold) {
+          toArchive.add(s.id);
+        }
+      }
+    }
+    const maxActive = config.maxActiveSessionsPerProject;
+    if (maxActive > 0 && categorySessions.length > maxActive) {
+      const sorted = [...categorySessions].sort((a, b) => a.lastActivity - b.lastActivity);
+      const excess = categorySessions.length - maxActive;
+      for (let i = 0; i < excess; i++) {
+        toArchive.add(sorted[i].id);
+      }
+    }
+    for (const sessionId of toArchive) {
+      const session = categorySessions.find((s) => s.id === sessionId);
+      if (!session) continue;
+      console.log(
+        `[archive-manager] Auto-archiving session "${session.agentLabel}" (inactive: ${Math.round((now - session.lastActivity) / 864e5)}d)`
+      );
+      await archiveSession(
+        session,
+        guild,
+        "Auto-archived due to inactivity or session limit."
+      ).catch(
+        (err) => console.error(
+          `[archive-manager] Auto-archive failed for "${session.agentLabel}": ${err.message}`
+        )
+      );
+    }
+  }
+}
+function formatDuration(ms) {
+  const d = Math.floor(ms / 864e5);
+  const h = Math.floor(ms % 864e5 / 36e5);
+  const m = Math.floor(ms % 36e5 / 6e4);
+  if (d > 0) return `${d}d ${h}h`;
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+export {
+  loadArchived,
+  getArchivedSessions,
+  isArchivedProviderSession,
+  archiveSession,
+  checkAutoArchive
+};

package/dist/chunk-Q2AJ4UEK.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import {
+  Store,
+  getDataDir
+} from "./chunk-CBNENUW6.js";
+
+// src/discord/attachment-inbox.ts
+import { basename, extname, join } from "path";
+import { mkdir, writeFile } from "fs/promises";
+var attachmentStore = new Store("attachment-inbox.json");
+var attachmentAuditStore = new Store("attachment-download-audit.json");
+var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+var MAX_TOTAL_DOWNLOAD_BYTES = 100 * 1024 * 1024;
+var FETCH_TIMEOUT_MS = (() => {
+  const env = Number(process.env.WORKSPACECORD_ATTACHMENT_FETCH_TIMEOUT_MS ?? "");
+  if (Number.isFinite(env) && env > 0) {
+    return env;
+  }
+  return 15e3;
+})();
+var ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:"]);
+function makeKey(sessionId, messageId) {
+  return `${sessionId}:${messageId}`;
+}
+function normalizeAttachment(attachment, messageId, index) {
+  return {
+    attachmentId: attachment.id ?? `${messageId}-${index}`,
+    name: attachment.name ?? `attachment-${index + 1}`,
+    contentType: attachment.contentType ?? null,
+    sizeBytes: attachment.size ?? 0,
+    url: attachment.url ?? ""
+  };
+}
+function sanitizeFilename(name, attachmentId) {
+  const safeBase = basename(name).replace(/[^a-zA-Z0-9._-]/g, "_").replace(/_+/g, "_");
+  const ext = extname(safeBase);
+  const stem = safeBase.slice(0, ext ? -ext.length : void 0) || attachmentId;
+  const normalizedExt = ext.replace(/[^a-zA-Z0-9.]/g, "") || ".bin";
+  return `${stem}-${attachmentId}${normalizedExt}`;
+}
+async function readIndex() {
+  return await attachmentStore.read() ?? {};
+}
+async function writeIndex(index) {
+  await attachmentStore.write(index);
+}
+async function appendAudit(entry) {
+  const existing = await attachmentAuditStore.read() ?? [];
+  existing.push(entry);
+  await attachmentAuditStore.write(existing);
+}
+async function registerMessageAttachments(sessionId, messageId, attachments) {
+  const index = await readIndex();
+  const records = attachments.map((attachment, idx) => normalizeAttachment(attachment, messageId, idx));
+  index[makeKey(sessionId, messageId)] = records;
+  await writeIndex(index);
+  return records;
+}
+async function getMessageAttachments(sessionId, messageId, attachmentId) {
+  const index = await readIndex();
+  const records = index[makeKey(sessionId, messageId)] ?? [];
+  if (!attachmentId) return records;
+  return records.filter((record) => record.attachmentId === attachmentId);
+}
+async function fetchRegisteredAttachments(options) {
+  if (!options.currentSessionId) {
+    throw new Error("currentSessionId is required: session context must be provided for attachment downloads");
+  }
+  if (options.currentSessionId !== options.sessionId) {
+    throw new Error("current session mismatch: cross-session attachment download is not allowed");
+  }
+  const records = await getMessageAttachments(
+    options.sessionId,
+    options.messageId,
+    options.all ? void 0 : options.attachmentId
+  );
+  if (!options.all && !options.attachmentId) {
+    throw new Error("attachmentId is required unless --all is set");
+  }
+  if (records.length === 0) {
+    throw new Error("No registered attachments found for the requested message");
+  }
+  if (records.some((record) => !record.url)) {
+    throw new Error("Missing download URL for one or more attachments");
+  }
+  if (options.all) {
+    const totalBytes = records.reduce((sum, record) => sum + record.sizeBytes, 0);
+    if (totalBytes > MAX_TOTAL_DOWNLOAD_BYTES) {
+      throw new Error("Total attachment size exceeds --all limit");
+    }
+  }
+  const inboxDir = join(getDataDir(), "inbox", options.sessionId);
+  await mkdir(inboxDir, { recursive: true });
+  const downloaded = [];
+  for (const record of records) {
+    assertHttpUrl(record.url);
+    if (record.sizeBytes > MAX_ATTACHMENT_BYTES) {
+      throw new Error(`Attachment exceeds 25MB limit: ${record.name}`);
+    }
+    const response = await fetchWithTimeout(record.url, record);
+    if (!response.ok) {
+      throw new Error(`Failed to download attachment: ${record.name}`);
+    }
+    const bytes = Buffer.from(await readArrayBufferWithTimeout(response, record));
+    const filename = sanitizeFilename(record.name, record.attachmentId);
+    const path = join(inboxDir, filename);
+    await writeFile(path, bytes);
+    downloaded.push({
+      attachmentId: record.attachmentId,
+      name: record.name,
+      contentType: record.contentType,
+      sizeBytes: record.sizeBytes,
+      path
+    });
+  }
+  await appendAudit({
+    sessionId: options.sessionId,
+    messageId: options.messageId,
+    attachmentId: options.attachmentId,
+    all: options.all === true,
+    downloadedPaths: downloaded.map((item) => item.path),
+    timestampIso: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return downloaded;
+}
+function assertHttpUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new Error(`Invalid attachment URL: ${rawUrl}`);
+  }
+  if (!ALLOWED_PROTOCOLS.has(parsed.protocol)) {
+    throw new Error(`Attachment URL must use http or https: ${rawUrl}`);
+  }
+}
+async function readArrayBufferWithTimeout(response, record) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`Attachment download timed out: ${record.name}`));
+    }, FETCH_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([readResponseBody(response, record), timeoutPromise]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function fetchWithTimeout(url, record) {
+  const controller = new AbortController();
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`Attachment download timed out: ${record.name}`));
+    }, FETCH_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([fetch(url, { signal: controller.signal }), timeoutPromise]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function readResponseBody(response, record) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.byteLength > MAX_ATTACHMENT_BYTES) {
+      throw new Error(`Attachment exceeds 25MB limit: ${record.name}`);
+    }
+    return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    totalBytes += value.byteLength;
+    if (totalBytes > MAX_ATTACHMENT_BYTES) {
+      await reader.cancel("attachment too large");
+      throw new Error(`Attachment exceeds 25MB limit: ${record.name}`);
+    }
+    chunks.push(value);
+  }
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return combined.buffer;
+}
+
+export {
+  registerMessageAttachments,
+  fetchRegisteredAttachments
+};

package/dist/cli-framework-KMQXM2PO.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import {
+  runCli,
+  startBot
+} from "./chunk-G6CCOBUY.js";
+import "./chunk-Q2AJ4UEK.js";
+import "./chunk-PUKMHDXS.js";
+import "./chunk-IFSOU4XI.js";
+import "./chunk-D6J3X35H.js";
+import "./chunk-7KESUGJP.js";
+import "./chunk-CBNENUW6.js";
+import "./chunk-52OOARML.js";
+import "./chunk-K3NQKI34.js";
+export {
+  runCli,
+  startBot
+};

package/dist/cli.js

@@ -1,71 +1,23 @@
 #!/usr/bin/env node
+import {
+  runCli,
+  startBot
+} from "./chunk-G6CCOBUY.js";
+import "./chunk-Q2AJ4UEK.js";
+import "./chunk-PUKMHDXS.js";
+import "./chunk-IFSOU4XI.js";
+import "./chunk-D6J3X35H.js";
+import "./chunk-7KESUGJP.js";
+import "./chunk-CBNENUW6.js";
+import "./chunk-52OOARML.js";
+import "./chunk-K3NQKI34.js";
 
 // src/cli.ts
-var command = process.argv[2];
-switch (command) {
-  case "setup": {
-    const { handleConfig } = await import("./config-cli-F2B5SYHJ.js");
-    await handleConfig(["setup"]);
-    break;
-  }
-  case "config": {
-    const { handleConfig } = await import("./config-cli-F2B5SYHJ.js");
-    await handleConfig(process.argv.slice(3));
-    break;
-  }
-  case "start":
-  case void 0: {
-    const { startBot } = await import("./bot-B5HN4ZW6.js");
-    console.log("workspacecord starting...");
-    await startBot();
-    break;
-  }
-  case "project": {
-    const { handleProject } = await import("./project-cli-FEMPZIRQ.js");
-    await handleProject(process.argv.slice(3));
-    break;
-  }
-  case "daemon": {
-    const { handleDaemon } = await import("./daemon-NW4WRMQK.js");
-    await handleDaemon(process.argv[3]);
-    break;
-  }
-  case "codex": {
-    const { handleCodexCommand } = await import("./codex-launcher-IF2IPLBP.js");
-    await handleCodexCommand(process.argv.slice(3));
-    break;
-  }
-  case "help":
-  case "--help":
-  case "-h": {
-    console.log(`
-  \x1B[1mworkspacecord\x1B[0m \u2014 Discord bot for multi-agent coding sessions
-
-  \x1B[1mUsage:\x1B[0m
-    workspacecord                     Start the bot
-    workspacecord config setup        Interactive configuration wizard
-    workspacecord config get <key>    Read a config value
-    workspacecord config set <k> <v>  Write a config value
-    workspacecord config list         List all config values
-    workspacecord config path         Show config file path
-    workspacecord project <subcommand> Manage mounted projects
-    workspacecord daemon              Manage background service (install/uninstall/status)
-    workspacecord codex [options]     Launch managed Codex session with remote approval
-    workspacecord help                Show this help message
-
-  \x1B[1mQuick start:\x1B[0m
-    1. workspacecord config setup      Configure Discord app, token, permissions
-    2. workspacecord project init      Mount a local project
-    3. workspacecord                   Start the bot
-    4. /project setup project:<name> Bind a Discord category to the mounted project
-    5. /agent spawn label:<task>    Create an agent session
-
-  \x1B[2mhttps://github.com/xuhongbo/WorkspaceCord\x1B[0m
-`);
-    break;
-  }
-  default:
-    console.error(`Unknown command: ${command}`);
-    console.error("Run \x1B[36mworkspacecord help\x1B[0m for usage.");
-    process.exit(1);
-}
+void (async () => {
+  const { runCli: runCli2 } = await import("./cli-framework-KMQXM2PO.js");
+  await runCli2();
+})();
+export {
+  runCli,
+  startBot
+};

package/dist/{codex-launcher-IF2IPLBP.js → codex-launcher-OOF2WYQF.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   getConfigValue
-} from "./chunk-OKI4UVGY.js";
+} from "./chunk-52OOARML.js";
 import "./chunk-K3NQKI34.js";
 
 // src/cli/codex-launcher.ts

package/dist/{codex-provider-7CI5W34X.js → codex-provider-P7TDYK6B.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   config
-} from "./chunk-2LBNM64L.js";
-import "./chunk-OKI4UVGY.js";
+} from "./chunk-D6J3X35H.js";
+import "./chunk-52OOARML.js";
 import "./chunk-K3NQKI34.js";
 
 // src/providers/codex-provider.ts

package/dist/{config-cli-F2B5SYHJ.js → config-cli-YSKOXADF.js}

@@ -9,7 +9,7 @@ import {
   maskSensitive,
   setConfigValue,
   validateConfigValue
-} from "./chunk-OKI4UVGY.js";
+} from "./chunk-52OOARML.js";
 import "./chunk-K3NQKI34.js";
 
 // src/config-cli.ts
@@ -33,7 +33,7 @@ async function handleConfig(args) {
   const [subcommand, ...rest] = args;
   switch (subcommand) {
     case "setup": {
-      const { runSetup } = await import("./setup-TKOVXSME.js");
+      const { runSetup } = await import("./setup-QJ4HVVCU.js");
       await runSetup();
       break;
     }

package/dist/{project-cli-FEMPZIRQ.js → project-cli-QW5QYT6A.js}

@@ -7,7 +7,8 @@ import {
   removeProject,
   renameProject,
   unbindProjectCategory
-} from "./chunk-NIXZJTOZ.js";
+} from "./chunk-7KESUGJP.js";
+import "./chunk-CBNENUW6.js";
 import "./chunk-K3NQKI34.js";
 
 // src/project-cli.ts

package/dist/{project-registry-DQT5ORUU.js → project-registry-LL75XEUV.js}

@@ -13,7 +13,8 @@ import {
   setProjectHistoryChannel,
   unbindProjectCategory,
   updateProject
-} from "./chunk-NIXZJTOZ.js";
+} from "./chunk-7KESUGJP.js";
+import "./chunk-CBNENUW6.js";
 import "./chunk-K3NQKI34.js";
 export {
   bindProjectCategory,

package/dist/{setup-TKOVXSME.js → setup-QJ4HVVCU.js}

@@ -2,7 +2,7 @@
 import {
   getConfigValue,
   setConfigValue
-} from "./chunk-OKI4UVGY.js";
+} from "./chunk-52OOARML.js";
 import "./chunk-K3NQKI34.js";
 
 // src/setup.ts

package/dist/{thread-manager-5T46QTZF.js → thread-manager-DRWNFXXY.js}

@@ -2,6 +2,7 @@
 import {
   abortSession,
   abortSessionWithReason,
+  buildClaudeSubagentProviderSessionId,
   consumeAbortReason,
   continueSession,
   continueSessionWithOverrides,
@@ -15,13 +16,16 @@ import {
   getSessionByChannel,
   getSessionByCodexId,
   getSessionByProviderSession,
-  getSessionByProviderSessionId,
   getSessionByThread,
+  getSessionPermissionDetails,
+  getSessionPermissionSummary,
   getSessionsByCategory,
   loadSessions,
   registerLocalSession,
   resetWorkflowState,
   resolveCodexSessionFromMonitor,
+  resolveEffectiveClaudePermissionMode,
+  resolveEffectiveCodexOptions,
   sendMonitorPrompt,
   sendPrompt,
   setAgentPersona,
@@ -33,16 +37,18 @@ import {
   setVerbose,
   updateLocalObservation,
   updateSession,
+  updateSessionPermissions,
   updateWorkflowState
-} from "./chunk-TSBM3BNT.js";
-import "./chunk-2LBNM64L.js";
-import "./chunk-OKI4UVGY.js";
-import "./chunk-NIXZJTOZ.js";
-import "./chunk-WE4X3JB3.js";
+} from "./chunk-IFSOU4XI.js";
+import "./chunk-D6J3X35H.js";
+import "./chunk-7KESUGJP.js";
+import "./chunk-CBNENUW6.js";
+import "./chunk-52OOARML.js";
 import "./chunk-K3NQKI34.js";
 export {
   abortSession,
   abortSessionWithReason,
+  buildClaudeSubagentProviderSessionId,
   consumeAbortReason,
   continueSession,
   continueSessionWithOverrides,
@@ -56,13 +62,16 @@ export {
   getSessionByChannel,
   getSessionByCodexId,
   getSessionByProviderSession,
-  getSessionByProviderSessionId,
   getSessionByThread,
+  getSessionPermissionDetails,
+  getSessionPermissionSummary,
   getSessionsByCategory,
   loadSessions,
   registerLocalSession,
   resetWorkflowState,
   resolveCodexSessionFromMonitor,
+  resolveEffectiveClaudePermissionMode,
+  resolveEffectiveCodexOptions,
   sendMonitorPrompt,
   sendPrompt,
   setAgentPersona,
@@ -74,5 +83,6 @@ export {
   setVerbose,
   updateLocalObservation,
   updateSession,
+  updateSessionPermissions,
   updateWorkflowState
 };