@nemus-cli/nemus 0.2.1

package/dist/utils/tmux-dashboard.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HIDDEN_WINDOW = void 0;
+exports.getAgentPanes = getAgentPanes;
+exports.getHiddenPanes = getHiddenPanes;
+exports.findPaneForAgent = findPaneForAgent;
+exports.sortAgentsByPaneOrder = sortAgentsByPaneOrder;
+exports.sortAgentsByPidOrder = sortAgentsByPidOrder;
+exports.restoreHiddenPanes = restoreHiddenPanes;
+exports.resetLayout = resetLayout;
+exports.zoomPane = zoomPane;
+const child_process_1 = require("child_process");
+const dashboard_1 = require("../types/dashboard");
+const { sessionName } = dashboard_1.DASHBOARD_DEFAULTS;
+exports.HIDDEN_WINDOW = `${sessionName}:1`;
+/**
+ * Get agent panes in the main dashboard window (excludes sidebar pane 0).
+ */
+function getAgentPanes() {
+    const result = (0, child_process_1.spawnSync)('tmux', [
+        'list-panes', '-t', sessionName, '-F',
+        '#{pane_index} #{pane_pid}',
+    ], { stdio: 'pipe' });
+    if (!result.stdout)
+        return [];
+    return result.stdout.toString().trim().split('\n')
+        .filter(l => l.trim())
+        .map(line => {
+        const [index, pid] = line.split(' ');
+        return { index, pid: parseInt(pid, 10) || 0 };
+    })
+        .filter(p => p.index !== '0');
+}
+/**
+ * Get panes from the hidden window (window 1) used during zoom.
+ */
+function getHiddenPanes() {
+    const result = (0, child_process_1.spawnSync)('tmux', [
+        'list-panes', '-t', exports.HIDDEN_WINDOW, '-F',
+        '#{pane_index} #{pane_pid}',
+    ], { stdio: 'pipe' });
+    if (!result.stdout)
+        return [];
+    return result.stdout.toString().trim().split('\n')
+        .filter(l => l.trim())
+        .map(line => {
+        const [index, pid] = line.split(' ');
+        return { index, pid: parseInt(pid, 10) || 0 };
+    });
+}
+/**
+ * Find the tmux pane matching an agent by PID (direct match only).
+ */
+function findPaneForAgent(agent, panes) {
+    return panes.find(p => p.pid === agent.pid) ?? null;
+}
+/**
+ * Sort agents to match tmux pane order (top-to-bottom) by PID.
+ */
+function sortAgentsByPaneOrder(agents, panes) {
+    const pidToIndex = new Map();
+    panes.forEach((p, i) => pidToIndex.set(p.pid, i));
+    return [...agents].sort((a, b) => {
+        const aIdx = pidToIndex.get(a.pid) ?? 999;
+        const bIdx = pidToIndex.get(b.pid) ?? 999;
+        return aIdx - bIdx;
+    });
+}
+/**
+ * Sort agents by an explicit PID order array (used during zoom to
+ * preserve the original order regardless of current pane positions).
+ */
+function sortAgentsByPidOrder(agents, pidOrder) {
+    const pidToIndex = new Map();
+    pidOrder.forEach((pid, i) => pidToIndex.set(pid, i));
+    return [...agents].sort((a, b) => {
+        const aIdx = pidToIndex.get(a.pid) ?? 999;
+        const bIdx = pidToIndex.get(b.pid) ?? 999;
+        return aIdx - bIdx;
+    });
+}
+/**
+ * Restore all panes from the hidden window back to the main window,
+ * then reorder them to match the given original PID order.
+ */
+function restoreHiddenPanes(originalPidOrder) {
+    // First, bring all hidden panes back (order may be wrong)
+    for (let i = 0; i < 20; i++) {
+        const winCheck = (0, child_process_1.spawnSync)('tmux', [
+            'list-windows', '-t', sessionName, '-F', '#{window_index}',
+        ], { stdio: 'pipe' });
+        if (!winCheck.stdout || !winCheck.stdout.toString().split('\n').some(l => l.trim() === '1'))
+            break;
+        const hidden = getHiddenPanes();
+        if (hidden.length === 0)
+            break;
+        const result = (0, child_process_1.spawnSync)('tmux', [
+            'join-pane', '-d',
+            '-s', `${exports.HIDDEN_WINDOW}.${hidden[0].index}`,
+            '-t', `${sessionName}:0`,
+        ], { stdio: 'pipe' });
+        if (result.status !== 0)
+            break;
+    }
+    // If we have a desired order, reorder panes by swapping them into place
+    if (originalPidOrder && originalPidOrder.length > 0) {
+        reorderPanesByPid(originalPidOrder);
+    }
+}
+/**
+ * Reorder agent panes to match the given PID order using swap-pane.
+ * Uses a simple selection sort: for each position, find the pane with
+ * the correct PID and swap it into place.
+ */
+function reorderPanesByPid(desiredPidOrder) {
+    for (let i = 0; i < desiredPidOrder.length; i++) {
+        const targetPid = desiredPidOrder[i];
+        const currentPanes = getAgentPanes();
+        // Find the current index of the pane with the desired PID
+        const currentIdx = currentPanes.findIndex(p => p.pid === targetPid);
+        if (currentIdx === -1)
+            continue; // pane not found (maybe died)
+        // The pane that should be at position i
+        const shouldBeAt = currentPanes[i];
+        if (!shouldBeAt)
+            continue;
+        // If already in the right position, skip
+        if (currentPanes[currentIdx].index === shouldBeAt.index)
+            continue;
+        // Swap the pane at position i with the pane that has the correct PID
+        (0, child_process_1.spawnSync)('tmux', [
+            'swap-pane',
+            '-s', `${sessionName}:0.${currentPanes[currentIdx].index}`,
+            '-t', `${sessionName}:0.${shouldBeAt.index}`,
+        ], { stdio: 'pipe' });
+    }
+}
+/**
+ * Reset to normal layout: restore hidden panes + rebalance.
+ */
+function resetLayout() {
+    restoreHiddenPanes();
+    (0, child_process_1.spawnSync)('tmux', ['select-layout', '-t', sessionName, 'main-vertical'], { stdio: 'pipe' });
+    (0, child_process_1.spawnSync)('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+    (0, child_process_1.spawnSync)('tmux', ['select-pane', '-t', `${sessionName}:0.0`], { stdio: 'pipe' });
+}
+/**
+ * Zoom: hide all other agent panes to a hidden window.
+ * First pane: break-pane (creates window 1).
+ * Subsequent panes: join-pane into existing window 1.
+ */
+function zoomPane(targetPane) {
+    const targetPid = targetPane.pid;
+    let hiddenWindowExists = false;
+    const winCheck = (0, child_process_1.spawnSync)('tmux', [
+        'list-windows', '-t', sessionName, '-F', '#{window_index}',
+    ], { stdio: 'pipe' });
+    if (winCheck.stdout && winCheck.stdout.toString().split('\n').some(l => l.trim() === '1')) {
+        hiddenWindowExists = true;
+    }
+    for (let i = 0; i < 20; i++) {
+        const currentPanes = getAgentPanes();
+        const toHide = currentPanes.find(p => p.pid !== targetPid);
+        if (!toHide)
+            break;
+        if (!hiddenWindowExists) {
+            (0, child_process_1.spawnSync)('tmux', [
+                'break-pane', '-d',
+                '-s', `${sessionName}:0.${toHide.index}`,
+            ], { stdio: 'pipe' });
+            hiddenWindowExists = true;
+        }
+        else {
+            (0, child_process_1.spawnSync)('tmux', [
+                'join-pane', '-d',
+                '-s', `${sessionName}:0.${toHide.index}`,
+                '-t', exports.HIDDEN_WINDOW,
+            ], { stdio: 'pipe' });
+        }
+    }
+    (0, child_process_1.spawnSync)('tmux', ['select-layout', '-t', `${sessionName}:0`, 'main-vertical'], { stdio: 'pipe' });
+    (0, child_process_1.spawnSync)('tmux', ['resize-pane', '-t', `${sessionName}:0.0`, '-x', '32'], { stdio: 'pipe' });
+    (0, child_process_1.spawnSync)('tmux', ['select-pane', '-t', `${sessionName}:0.0`], { stdio: 'pipe' });
+}

package/dist/utils/validation.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorkspaceNameConflict = exports.sanitizeWorkspaceName = exports.checkWorkspaceExists = exports.validateWorkspaceName = exports.safeWorkspacePath = exports.assertSafeWorkspaceName = exports.isSafePathSegment = void 0;
+const fs = __importStar(require("fs/promises"));
+const config_1 = require("./config");
+const path = __importStar(require("path"));
+const WORKSPACE_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+/**
+ * Allowlist for a single, safe path segment used as a workspace (or suite) name.
+ * Alphanumerics plus hyphen/underscore only — it cannot express a path
+ * separator, a Windows drive, a leading `~`, or a `.`/`..` traversal component,
+ * so a value that matches this can never escape its parent directory.
+ */
+const isSafePathSegment = (name) => typeof name === 'string' && name.length > 0 && name.length <= 64 && WORKSPACE_NAME_REGEX.test(name);
+exports.isSafePathSegment = isSafePathSegment;
+/**
+ * Throw unless `name` is a safe workspace-name path segment. Use this in any
+ * handler that receives a workspace/suite name from an untrusted caller (e.g.
+ * the MCP server, whose Zod schemas otherwise accept any string) BEFORE the
+ * name is used to build a filesystem path.
+ */
+const assertSafeWorkspaceName = (name, label = 'workspace name') => {
+    if (!(0, exports.isSafePathSegment)(name)) {
+        throw new Error(`Invalid ${label} "${String(name)}": only letters, numbers, hyphens, and underscores are allowed ` +
+            `(no path separators, "..", or other special characters).`);
+    }
+};
+exports.assertSafeWorkspaceName = assertSafeWorkspaceName;
+/**
+ * Validate a workspace name and resolve it to an absolute path guaranteed to sit
+ * directly inside WORKSPACES_DIR. This is the single choke point every code path
+ * (especially the MCP handlers) must use instead of a raw
+ * `path.join(WORKSPACES_DIR, name)` — it closes the path-traversal vector where
+ * a caller could pass e.g. "../../etc" as a workspace name to read, write,
+ * delete, or run commands outside the workspaces sandbox.
+ *
+ * Two independent guards: the allowlist above (which cannot express traversal)
+ * and a resolved-path containment check (belt-and-suspenders, also catches any
+ * future change that loosens the allowlist).
+ */
+const safeWorkspacePath = (name) => {
+    (0, exports.assertSafeWorkspaceName)(name);
+    const base = path.resolve(config_1.WORKSPACES_DIR);
+    const resolved = path.resolve(base, name);
+    if (resolved !== base && !resolved.startsWith(base + path.sep)) {
+        throw new Error(`Refusing to use a workspace path outside the workspaces directory: "${name}"`);
+    }
+    return resolved;
+};
+exports.safeWorkspacePath = safeWorkspacePath;
+const validateWorkspaceName = (name) => {
+    if (!name || name.trim().length === 0) {
+        return 'Workspace name cannot be empty';
+    }
+    if (!WORKSPACE_NAME_REGEX.test(name)) {
+        return 'Workspace name must contain only alphanumeric characters, hyphens, and underscores (spaces are automatically converted to hyphens)';
+    }
+    if (name.length < 3) {
+        return 'Workspace name must be at least 3 characters long';
+    }
+    if (name.length > 50) {
+        return 'Workspace name must be less than 50 characters';
+    }
+    return true;
+};
+exports.validateWorkspaceName = validateWorkspaceName;
+const checkWorkspaceExists = async (name) => {
+    const workspacePath = path.join(config_1.WORKSPACES_DIR, name);
+    try {
+        await fs.access(workspacePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.checkWorkspaceExists = checkWorkspaceExists;
+const sanitizeWorkspaceName = (name) => {
+    return name.trim().toLowerCase().replace(/ +/g, '-');
+};
+exports.sanitizeWorkspaceName = sanitizeWorkspaceName;
+/**
+ * Resolves a workspace name conflict by generating a unique alternative name.
+ *
+ * Strategy:
+ *   1. Try appending each provided candidate suffix (e.g. repo names): `<name>-<candidate>`
+ *   2. Fall back to numeric suffixes: `<name>-2`, `<name>-3`, …
+ *
+ * @param baseName   - The sanitized workspace name that already exists.
+ * @param candidates - Optional list of preferred suffixes to try first (e.g. selected repo names).
+ * @returns A workspace name that does not yet exist on disk and passes validation.
+ */
+const resolveWorkspaceNameConflict = async (baseName, candidates = []) => {
+    // 1. Try candidate-based suffixes (e.g. repo names)
+    for (const candidate of candidates) {
+        const suffix = (0, exports.sanitizeWorkspaceName)(candidate)
+            .replace(/[^a-z0-9_-]/g, '-') // extra safety — strip any bad chars after sanitise
+            .replace(/-+/g, '-') // collapse consecutive hyphens
+            .replace(/^-|-$/g, ''); // trim leading/trailing hyphens
+        if (!suffix)
+            continue;
+        const attempt = `${baseName}-${suffix}`;
+        if ((0, exports.validateWorkspaceName)(attempt) !== true)
+            continue;
+        const exists = await (0, exports.checkWorkspaceExists)(attempt);
+        if (!exists)
+            return attempt;
+    }
+    // 2. Fall back to numeric suffixes
+    for (let i = 2; i <= 99; i++) {
+        const attempt = `${baseName}-${i}`;
+        if ((0, exports.validateWorkspaceName)(attempt) !== true)
+            continue;
+        const exists = await (0, exports.checkWorkspaceExists)(attempt);
+        if (!exists)
+            return attempt;
+    }
+    throw new Error(`Could not resolve workspace name conflict for "${baseName}" — all attempted names already exist.`);
+};
+exports.resolveWorkspaceNameConflict = resolveWorkspaceNameConflict;

package/dist/utils/version-check.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdate = checkForUpdate;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const config_1 = require("./config");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const VERSION_CHECK_FILE = path.join(config_1.CACHE_DIR, 'last-version-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+function compareVersions(current, latest) {
+    const a = current.split('.').map(Number);
+    const b = latest.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) < (b[i] || 0))
+            return -1;
+        if ((a[i] || 0) > (b[i] || 0))
+            return 1;
+    }
+    return 0;
+}
+async function loadCache() {
+    try {
+        const content = await fs.readFile(VERSION_CHECK_FILE, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function saveCache(cache) {
+    try {
+        await fs.mkdir(config_1.CACHE_DIR, { recursive: true });
+        await fs.writeFile(VERSION_CHECK_FILE, JSON.stringify(cache), 'utf-8');
+    }
+    catch {
+        // Silently ignore cache write failures
+    }
+}
+async function fetchLatestVersion() {
+    try {
+        const { stdout } = await execFileAsync('npm', ['view', '@nemus-cli/nemus', 'version'], {
+            timeout: 5000,
+        });
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a newer version is available.
+ * Returns upgrade message string if an update is available, null otherwise.
+ * Caches the result for 24 hours to avoid spamming npm on every invocation.
+ * This is designed to be non-blocking and best-effort — failures are silent.
+ */
+async function checkForUpdate() {
+    try {
+        const currentVersion = (0, config_1.getPackageVersion)();
+        const cache = await loadCache();
+        // If we checked recently, use cached result
+        if (cache) {
+            const elapsed = Date.now() - new Date(cache.checkedAt).getTime();
+            if (elapsed < CHECK_INTERVAL_MS) {
+                if (compareVersions(currentVersion, cache.latestVersion) < 0) {
+                    return formatUpdateMessage(currentVersion, cache.latestVersion);
+                }
+                return null;
+            }
+        }
+        // Fetch latest version from npm (async with timeout)
+        const latestVersion = await fetchLatestVersion();
+        if (!latestVersion)
+            return null;
+        await saveCache({ checkedAt: new Date().toISOString(), latestVersion });
+        if (compareVersions(currentVersion, latestVersion) < 0) {
+            return formatUpdateMessage(currentVersion, latestVersion);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function formatUpdateMessage(current, latest) {
+    return `\x1b[33m[nemus] Update available: ${current} -> ${latest}. Run: npm install -g @nemus-cli/nemus@latest\x1b[0m`;
+}

package/dist/utils/workspace-meta.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purgeExpiredArchives = exports.unarchiveWorkspace = exports.archiveWorkspace = exports.listWorkspaces = exports.loadMetadata = exports.saveMetadata = exports.createMetadata = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const logger_1 = require("./logger");
+const config_1 = require("./config");
+const validation_1 = require("./validation");
+const ARCHIVE_EXPIRY_DAYS = 30;
+const createMetadata = (workspaceName, cloneResults, options) => {
+    const repositories = cloneResults.map(result => ({
+        name: result.repo.name,
+        directoryName: result.directoryName,
+        owner: result.repo.owner.login,
+        clonedAt: result.clonedAt || new Date().toISOString(),
+        cloneUrl: (0, config_1.getCloneUrl)(result.repo),
+        status: result.status,
+        error: result.error,
+    }));
+    return {
+        workspaceName,
+        createdAt: new Date().toISOString(),
+        repositories,
+        ...(options?.prompt ? { prompt: options.prompt } : {}),
+    };
+};
+exports.createMetadata = createMetadata;
+const saveMetadata = async (workspacePath, metadata) => {
+    try {
+        const metaPath = path.join(workspacePath, config_1.META_FILENAME);
+        await fs.writeFile(metaPath, JSON.stringify(metadata, null, 2), 'utf-8');
+        (0, logger_1.logSuccess)('Saved workspace metadata');
+    }
+    catch (error) {
+        (0, logger_1.logWarning)('Failed to save workspace metadata');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+    }
+};
+exports.saveMetadata = saveMetadata;
+const loadMetadata = async (workspacePath) => {
+    try {
+        const metaPath = path.join(workspacePath, config_1.META_FILENAME);
+        const content = await fs.readFile(metaPath, 'utf-8');
+        const metadata = JSON.parse(content);
+        // Backward compatibility: default directoryName to name for old entries
+        for (const repo of metadata.repositories) {
+            if (!repo.directoryName) {
+                repo.directoryName = repo.name;
+            }
+        }
+        return metadata;
+    }
+    catch {
+        return null;
+    }
+};
+exports.loadMetadata = loadMetadata;
+const listWorkspaces = async (includeArchived = false) => {
+    try {
+        await fs.access(config_1.WORKSPACES_DIR);
+    }
+    catch {
+        return [];
+    }
+    try {
+        // Lazily purge expired archives on every list call
+        await (0, exports.purgeExpiredArchives)();
+        const entries = await fs.readdir(config_1.WORKSPACES_DIR, { withFileTypes: true });
+        const workspaces = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const workspacePath = path.join(config_1.WORKSPACES_DIR, entry.name);
+                const metadata = await (0, exports.loadMetadata)(workspacePath);
+                // Filter based on archive status
+                if (!includeArchived && metadata?.archivedAt) {
+                    continue;
+                }
+                workspaces.push({
+                    name: entry.name,
+                    path: workspacePath,
+                    metadata,
+                });
+            }
+        }
+        return workspaces;
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to list workspaces');
+        return [];
+    }
+};
+exports.listWorkspaces = listWorkspaces;
+const archiveWorkspace = async (workspaceName) => {
+    const workspacePath = (0, validation_1.safeWorkspacePath)(workspaceName);
+    const metadata = await (0, exports.loadMetadata)(workspacePath);
+    if (!metadata) {
+        throw new Error(`Workspace not found: ${workspaceName}`);
+    }
+    if (metadata.archivedAt) {
+        throw new Error(`Workspace is already archived: ${workspaceName}`);
+    }
+    metadata.archivedAt = new Date().toISOString();
+    await (0, exports.saveMetadata)(workspacePath, metadata);
+};
+exports.archiveWorkspace = archiveWorkspace;
+const unarchiveWorkspace = async (workspaceName) => {
+    const workspacePath = (0, validation_1.safeWorkspacePath)(workspaceName);
+    const metadata = await (0, exports.loadMetadata)(workspacePath);
+    if (!metadata) {
+        throw new Error(`Workspace not found: ${workspaceName}`);
+    }
+    if (!metadata.archivedAt) {
+        throw new Error(`Workspace is not archived: ${workspaceName}`);
+    }
+    delete metadata.archivedAt;
+    await (0, exports.saveMetadata)(workspacePath, metadata);
+};
+exports.unarchiveWorkspace = unarchiveWorkspace;
+const purgeExpiredArchives = async () => {
+    try {
+        await fs.access(config_1.WORKSPACES_DIR);
+    }
+    catch {
+        return;
+    }
+    try {
+        const entries = await fs.readdir(config_1.WORKSPACES_DIR, { withFileTypes: true });
+        const now = Date.now();
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const workspacePath = path.join(config_1.WORKSPACES_DIR, entry.name);
+            const metadata = await (0, exports.loadMetadata)(workspacePath);
+            if (!metadata?.archivedAt)
+                continue;
+            const archivedTime = new Date(metadata.archivedAt).getTime();
+            const daysSinceArchive = (now - archivedTime) / (1000 * 60 * 60 * 24);
+            if (daysSinceArchive > ARCHIVE_EXPIRY_DAYS) {
+                await fs.rm(workspacePath, { recursive: true, force: true });
+                process.stderr.write(`Purged expired archive: ${entry.name}\n`);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            process.stderr.write(`Error purging expired archives: ${error.message}\n`);
+        }
+    }
+};
+exports.purgeExpiredArchives = purgeExpiredArchives;