office-core 0.1.4 → 0.2.0

package/.runtime-dist/scripts/lib/cli-support.js

@@ -0,0 +1,199 @@
+import { appendFile, cp, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn, spawnSync } from 'node:child_process';
+export function parseCliArgs(argv, options = {}) {
+    const bools = new Set(options.boolean ?? []);
+    const values = new Set(options.value ?? []);
+    const aliases = options.aliases ?? {};
+    const out = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const item = argv[i];
+        if (!item.startsWith('--')) {
+            throw new Error(`Unexpected positional argument: ${item}`);
+        }
+        const rawKey = item.slice(2);
+        const key = aliases[rawKey] ?? rawKey;
+        if (!bools.has(key) && !values.has(key)) {
+            throw new Error(`Unknown option: --${rawKey}`);
+        }
+        if (bools.has(key)) {
+            const next = argv[i + 1];
+            if (next && !next.startsWith('--')) {
+                out[key] = next;
+                i += 1;
+            }
+            else {
+                out[key] = 'true';
+            }
+            continue;
+        }
+        const next = argv[i + 1];
+        if (!next || next.startsWith('--')) {
+            throw new Error(`Missing value for --${rawKey}`);
+        }
+        out[key] = next;
+        i += 1;
+    }
+    return out;
+}
+export function parseBooleanLike(value, fallback) {
+    if (value == null || value === '') {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`Invalid boolean value: ${value}`);
+}
+export function parseNumberLike(value, fallback, label = 'number') {
+    if (value == null || value === '') {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid ${label}: ${value}`);
+    }
+    return parsed;
+}
+export async function openExternal(target) {
+    const command = process.platform === 'win32'
+        ? 'cmd.exe'
+        : process.platform === 'darwin'
+            ? 'open'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', target] : [target];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.on('error', reject);
+        child.unref();
+        resolve();
+    });
+}
+export function escapeBatch(value) {
+    return value.replace(/"/g, '""');
+}
+export function buildStartupLauncher(rootDir) {
+    const runtimeEntry = path.join(rootDir, 'bin', 'office-core.mjs');
+    return [
+        '@echo off',
+        'setlocal',
+        `cd /d "${escapeBatch(rootDir)}"`,
+        'where node >nul 2>nul',
+        'if errorlevel 1 (',
+        '  echo Node.js was not found on PATH.',
+        '  exit /b 1',
+        ')',
+        `start "office core" cmd /c "cd /d ""${escapeBatch(rootDir)}"" && node ""${escapeBatch(runtimeEntry)}"" start"`,
+        'endlocal',
+        '',
+    ].join('\r\n');
+}
+export function buildDesktopLauncher(rootDir) {
+    const runtimeEntry = path.join(rootDir, 'bin', 'office-core.mjs');
+    return [
+        '@echo off',
+        'setlocal',
+        `cd /d "${escapeBatch(rootDir)}"`,
+        `node "${escapeBatch(runtimeEntry)}"`,
+        'if errorlevel 1 pause',
+        'endlocal',
+        '',
+    ].join('\r\n');
+}
+export function buildDashboardLauncher(rootDir) {
+    const runtimeEntry = path.join(rootDir, 'bin', 'office-core.mjs');
+    return [
+        '@echo off',
+        'setlocal',
+        `cd /d "${escapeBatch(rootDir)}"`,
+        `node "${escapeBatch(runtimeEntry)}" open`,
+        'if errorlevel 1 pause',
+        'endlocal',
+        '',
+    ].join('\r\n');
+}
+export async function appendLogLine(logPath, line) {
+    await mkdir(path.dirname(logPath), { recursive: true });
+    await appendFile(logPath, `${new Date().toISOString()} ${line}\n`, 'utf8');
+}
+export async function readRecentLines(logPath, maxLines = 120) {
+    try {
+        const raw = await readFile(logPath, 'utf8');
+        return raw.split(/\r?\n/).filter(Boolean).slice(-maxLines);
+    }
+    catch {
+        return [];
+    }
+}
+export async function createSupportBundle(params) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const baseName = `${params.bundleNamePrefix}-${stamp}`;
+    const stagingRoot = await mkdtemp(path.join(os.tmpdir(), `${params.bundleNamePrefix}-`));
+    const bundleDir = path.join(stagingRoot, baseName);
+    await mkdir(bundleDir, { recursive: true });
+    await writeFile(path.join(bundleDir, 'bundle-metadata.json'), JSON.stringify(params.metadata, null, 2), 'utf8');
+    for (const entry of params.includePaths) {
+        if (!existsSync(entry.source)) {
+            continue;
+        }
+        const destination = path.join(bundleDir, entry.target ?? path.basename(entry.source));
+        await mkdir(path.dirname(destination), { recursive: true });
+        await cp(entry.source, destination, { recursive: true, force: true });
+    }
+    await mkdir(params.outputRoot, { recursive: true });
+    if (process.platform === 'win32') {
+        const zipPath = path.join(params.outputRoot, `${baseName}.zip`);
+        const compress = spawnSync('powershell.exe', [
+            '-NoProfile',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-Command',
+            `Compress-Archive -LiteralPath '${bundleDir.replace(/'/g, "''")}' -DestinationPath '${zipPath.replace(/'/g, "''")}' -Force`,
+        ], { encoding: 'utf8', windowsHide: true });
+        if (compress.status === 0 && existsSync(zipPath)) {
+            await rm(stagingRoot, { recursive: true, force: true });
+            return { outputPath: zipPath, mode: 'zip' };
+        }
+    }
+    else {
+        const zipPath = path.join(params.outputRoot, `${baseName}.zip`);
+        const zip = spawnSync('zip', ['-qr', zipPath, baseName], {
+            cwd: stagingRoot,
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+        if (zip.status === 0 && existsSync(zipPath)) {
+            await rm(stagingRoot, { recursive: true, force: true });
+            return { outputPath: zipPath, mode: 'zip' };
+        }
+    }
+    const fallbackDir = path.join(params.outputRoot, baseName);
+    await rm(fallbackDir, { recursive: true, force: true }).catch(() => undefined);
+    await cp(bundleDir, fallbackDir, { recursive: true, force: true });
+    await rm(stagingRoot, { recursive: true, force: true });
+    return { outputPath: fallbackDir, mode: 'folder' };
+}
+export async function describePathState(targetPath) {
+    try {
+        const info = await stat(targetPath);
+        if (info.isDirectory()) {
+            const items = await readdir(targetPath);
+            return `${targetPath} (${items.length} items)`;
+        }
+        return `${targetPath} (${info.size} bytes)`;
+    }
+    catch {
+        return `${targetPath} (missing)`;
+    }
+}

package/.runtime-dist/scripts/lib/host-config.js

@@ -1,16 +1,29 @@
-import { existsSync } from "node:fs";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import { existsSync } from 'node:fs';
+import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
 const HOST_CONFIG_VERSION = 1;
-const HOST_CONFIG_DIRNAME = "office-host";
-const LEGACY_HOST_CONFIG_DIRNAME = "double-penetration";
-const HOST_CONFIG_FILENAME = "host-config.json";
-const HOST_SESSIONS_FILENAME = "host-sessions.json";
-const DEFAULT_LOCAL_HOST_TOKEN = "office-host-local-token";
+const HOST_CONFIG_DIRNAME = 'office-host';
+const LEGACY_HOST_CONFIG_DIRNAME = 'double-penetration';
+const HOST_CONFIG_FILENAME = 'host-config.json';
+const HOST_SESSIONS_FILENAME = 'host-sessions.json';
+const DEFAULT_LOCAL_HOST_TOKEN = 'office-host-local-token';
 export function getHostConfigDir() {
     return path.join(baseAppDataDir(), HOST_CONFIG_DIRNAME);
 }
+export function getHostLogsDir() {
+    return path.join(getHostConfigDir(), 'logs');
+}
+export function getHostDiagnosticsDir() {
+    return path.join(getHostConfigDir(), 'diagnostics');
+}
+export function getSupportBundlesDir() {
+    return path.join(getHostDiagnosticsDir(), 'support-bundles');
+}
+export function getHostLogPath() {
+    return path.join(getHostLogsDir(), 'office-host.log');
+}
 export function getHostConfigPath() {
     return path.join(getHostConfigDir(), HOST_CONFIG_FILENAME);
 }
@@ -20,6 +33,10 @@ export function getHostSessionsPath() {
 export function getLegacyHostConfigDir() {
     return path.join(baseAppDataDir(), LEGACY_HOST_CONFIG_DIRNAME);
 }
+export async function appendHostLog(message) {
+    await mkdir(getHostLogsDir(), { recursive: true });
+    await appendFile(getHostLogPath(), `${new Date().toISOString()} ${message}\n`, 'utf8');
+}
 export async function loadHostConfig() {
     const filePath = firstExistingPath([
         path.join(getHostConfigDir(), HOST_CONFIG_FILENAME),
@@ -28,18 +45,19 @@ export async function loadHostConfig() {
     if (!filePath) {
         return null;
     }
-    let parsed;
+    let raw = '';
     try {
-        const raw = await readFile(filePath, "utf8");
-        parsed = parseLooseJson(raw);
-    }
-    catch {
-        return null;
+        raw = await readFile(filePath, 'utf8');
+        const parsed = parseLooseJson(raw);
+        if (!parsed || parsed.version !== HOST_CONFIG_VERSION) {
+            return null;
+        }
+        return normalizeConfig(parsed);
     }
-    if (!parsed || parsed.version !== HOST_CONFIG_VERSION) {
+    catch (error) {
+        await quarantineCorruptFile(filePath, raw, error);
         return null;
     }
-    return normalizeConfig(parsed);
 }
 export async function upsertHostConfig(overrides) {
     const existing = await loadHostConfig();
@@ -50,8 +68,8 @@ export async function upsertHostConfig(overrides) {
         host_id: overrides.host_id ?? existing?.host_id ?? `host_${sanitize(machineName)}_${crypto.randomUUID().slice(0, 8)}`,
         display_name: overrides.display_name ?? existing?.display_name ?? `${machineName} host`,
         machine_name: machineName,
-        base_url: overrides.base_url ?? existing?.base_url ?? "http://127.0.0.1:8787",
-        project_id: overrides.project_id ?? existing?.project_id ?? "prj_local",
+        base_url: overrides.base_url ?? existing?.base_url ?? 'http://127.0.0.1:8787',
+        project_id: overrides.project_id ?? existing?.project_id ?? 'prj_local',
         workdir: path.resolve(overrides.workdir ?? existing?.workdir ?? process.cwd()),
         token: overrides.token ?? existing?.token ?? DEFAULT_LOCAL_HOST_TOKEN,
         room_cursor_seq: overrides.room_cursor_seq ?? existing?.room_cursor_seq ?? 0,
@@ -62,6 +80,7 @@ export async function upsertHostConfig(overrides) {
     });
     await mkdir(getHostConfigDir(), { recursive: true });
     await writeAtomicJson(getHostConfigPath(), next);
+    await appendHostLog(`[config] updated project=${next.project_id} host=${next.host_id} workdir=${next.workdir}`);
     return next;
 }
 export async function loadPersistedHostSessions() {
@@ -73,16 +92,17 @@ export async function loadPersistedHostSessions() {
         return [];
     }
     try {
-        const raw = await readFile(filePath, "utf8");
+        const raw = await readFile(filePath, 'utf8');
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed)) {
             return [];
         }
         return parsed
-            .filter((entry) => entry && typeof entry === "object" && entry.session_id)
+            .filter((entry) => entry && typeof entry === 'object' && entry.session_id)
             .map((entry) => normalizePersistedSession(entry));
     }
-    catch {
+    catch (error) {
+        await quarantineCorruptFile(filePath, '', error);
         return [];
     }
 }
@@ -92,20 +112,23 @@ export async function savePersistedHostSessions(sessions) {
     await writeAtomicJson(getHostSessionsPath(), next);
 }
 export function getStartupLauncherPath() {
-    return path.join(baseAppDataDir(), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", "office-host.bat");
+    return path.join(baseAppDataDir(), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup', 'office-host.bat');
+}
+export function getDesktopLauncherPath() {
+    return path.join(baseAppDataDir(), 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Office Core.bat');
 }
 function normalizeConfig(input) {
     return {
         version: HOST_CONFIG_VERSION,
-        host_id: String(input.host_id ?? "").trim(),
-        display_name: String(input.display_name ?? "").trim(),
+        host_id: String(input.host_id ?? '').trim(),
+        display_name: String(input.display_name ?? '').trim(),
         machine_name: String(input.machine_name ?? os.hostname()).trim(),
-        base_url: String(input.base_url ?? "http://127.0.0.1:8787").trim().replace(/\/$/, ""),
-        project_id: String(input.project_id ?? "prj_local").trim(),
+        base_url: String(input.base_url ?? 'http://127.0.0.1:8787').trim().replace(/\/$/, ''),
+        project_id: String(input.project_id ?? 'prj_local').trim(),
         workdir: path.resolve(String(input.workdir ?? process.cwd())),
         token: String(input.token ?? DEFAULT_LOCAL_HOST_TOKEN).trim(),
-        room_cursor_seq: Number(input.room_cursor_seq ?? 0),
-        poll_ms: Number(input.poll_ms ?? 5000),
+        room_cursor_seq: finiteNumber(input.room_cursor_seq, 0),
+        poll_ms: finiteNumber(input.poll_ms, 5000),
         auto_start: Boolean(input.auto_start ?? true),
         created_at: String(input.created_at ?? new Date().toISOString()),
         updated_at: String(input.updated_at ?? new Date().toISOString()),
@@ -113,34 +136,34 @@ function normalizeConfig(input) {
 }
 function normalizePersistedSession(input) {
     return {
-        session_id: String(input.session_id ?? "").trim(),
+        session_id: String(input.session_id ?? '').trim(),
         project_id: input.project_id ? String(input.project_id) : null,
-        runner: input.runner === "claude" ? "claude" : "codex",
-        agent_id: String(input.agent_id ?? "").trim(),
-        mode: input.mode === "execute" || input.mode === "review" || input.mode === "attach" ? input.mode : "brainstorm",
+        runner: input.runner === 'claude' ? 'claude' : 'codex',
+        agent_id: String(input.agent_id ?? '').trim(),
+        mode: input.mode === 'execute' || input.mode === 'review' || input.mode === 'attach' ? input.mode : 'brainstorm',
         workdir: path.resolve(String(input.workdir ?? process.cwd())),
-        status: input.status === "completed" || input.status === "failed" ? input.status : "running",
+        status: input.status === 'completed' || input.status === 'failed' ? input.status : 'running',
         launched_at: String(input.launched_at ?? new Date().toISOString()),
         task_id: input.task_id ? String(input.task_id) : null,
-        effort: input.effort === "low" || input.effort === "medium" || input.effort === "max" || input.effort === "high"
+        effort: input.effort === 'low' || input.effort === 'medium' || input.effort === 'max' || input.effort === 'high'
             ? input.effort
-            : "high",
+            : 'high',
         shell_pid: Number.isFinite(Number(input.shell_pid)) ? Number(input.shell_pid) : null,
         script_dir: input.script_dir ? String(input.script_dir) : null,
         note: input.note ? String(input.note) : null,
         bootstrap: input.bootstrap
             ? {
-                session_id: String(input.bootstrap.session_id ?? "").trim(),
-                session_epoch: Number(input.bootstrap.session_epoch ?? 0),
-                session_token: String(input.bootstrap.session_token ?? ""),
-                bundle_seq: Number(input.bootstrap.bundle_seq ?? 1),
-                task_version: Number(input.bootstrap.task_version ?? 1),
+                session_id: String(input.bootstrap.session_id ?? '').trim(),
+                session_epoch: finiteNumber(input.bootstrap.session_epoch, 0),
+                session_token: String(input.bootstrap.session_token ?? ''),
+                bundle_seq: finiteNumber(input.bootstrap.bundle_seq, 1),
+                task_version: finiteNumber(input.bootstrap.task_version, 1),
             }
             : null,
     };
 }
 function sanitize(value) {
-    return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+    return value.replace(/[^a-zA-Z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase();
 }
 function firstExistingPath(paths) {
     for (const filePath of paths) {
@@ -155,7 +178,7 @@ function parseLooseJson(raw) {
         return JSON.parse(raw);
     }
     catch {
-        for (let index = raw.lastIndexOf("}"); index >= 0; index = raw.lastIndexOf("}", index - 1)) {
+        for (let index = raw.lastIndexOf('}'); index >= 0; index = raw.lastIndexOf('}', index - 1)) {
             const trimmed = raw.slice(0, index + 1).trim();
             try {
                 return JSON.parse(trimmed);
@@ -164,25 +187,36 @@ function parseLooseJson(raw) {
                 // keep walking backward until we hit the real JSON terminator
             }
         }
-        throw new SyntaxError("Unable to parse host config JSON");
+        throw new SyntaxError('Unable to parse host config JSON');
     }
 }
-async function writeAtomicJson(filePath, value) {
-    const tempPath = `${filePath}.tmp`;
+async function quarantineCorruptFile(filePath, raw, error) {
     try {
-        await writeFile(tempPath, JSON.stringify(value, null, 2), "utf8");
-        await rename(tempPath, filePath);
-    }
-    catch (error) {
-        await rm(tempPath, { force: true }).catch(() => undefined);
-        const code = error && typeof error === "object" && "code" in error ? String(error.code ?? "") : "";
-        if (code === "EPERM" || code === "EACCES" || code === "EBUSY") {
-            const fileLabel = path.basename(filePath);
-            throw new Error(`Unable to write ${fileLabel} at ${filePath}. Remove read-only protection or close any program using that file.`);
+        await mkdir(getHostDiagnosticsDir(), { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const target = path.join(getHostDiagnosticsDir(), `${path.basename(filePath)}.corrupt-${stamp}.json`);
+        if (raw) {
+            await writeFile(target, raw, 'utf8');
+        }
+        else if (existsSync(filePath)) {
+            await rename(filePath, target);
+            return;
         }
-        throw error;
+        await appendHostLog(`[config] quarantined corrupt config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
+    catch {
+        // ignore quarantine failures; returning null is still safer than crashing the CLI
+    }
+}
+async function writeAtomicJson(filePath, value) {
+    const tempPath = `${filePath}.tmp`;
+    await writeFile(tempPath, JSON.stringify(value, null, 2), 'utf8');
+    await rename(tempPath, filePath);
+}
+function finiteNumber(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
 }
 function baseAppDataDir() {
-    return process.env.APPDATA ?? path.join(process.env.USERPROFILE ?? os.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA ?? path.join(process.env.USERPROFILE ?? os.homedir(), 'AppData', 'Roaming');
 }

package/.runtime-dist/scripts/lib/local-runner.js

@@ -38,11 +38,21 @@ export function probeRunnerAvailability(kind, override) {
     if (process.platform === "win32") {
         return { available: existsSync(command) || queryWhere(command).length > 0, command };
     }
-    return { available: true, command };
+    const result = spawnSync('sh', ['-lc', `command -v ${shellEscape(command)} >/dev/null 2>&1`], {
+        windowsHide: true,
+    });
+    return { available: result.status === 0, command };
+}
+export function assertRunnerAvailable(kind, override) {
+    const probe = probeRunnerAvailability(kind, override);
+    if (!probe.available) {
+        throw new Error(`${kind} is not installed or is not on PATH.`);
+    }
+    return probe.command;
 }
 async function runCodex(input) {
     const outputDir = await mkdtemp(path.join(os.tmpdir(), "office-codex-"));
-    const command = resolveRunnerCommand("codex", process.env.CODEX_CMD);
+    const command = assertRunnerAvailable("codex", process.env.CODEX_CMD);
     const args = [
         "exec",
         "--json",
@@ -64,7 +74,7 @@ async function runCodex(input) {
     }
 }
 async function runClaude(input) {
-    const command = resolveRunnerCommand("claude", process.env.CLAUDE_CMD);
+    const command = assertRunnerAvailable("claude", process.env.CLAUDE_CMD);
     const args = [
         "-p",
         "--verbose",
@@ -94,6 +104,9 @@ function queryWhere(command) {
         .map((line) => line.trim())
         .filter(Boolean);
 }
+function shellEscape(value) {
+    return `'${String(value).replace(/'/g, `'\''`)}'`;
+}
 function buildWindowsFallbacks(kind) {
     const localAppData = process.env.LOCALAPPDATA ?? "";
     const appData = process.env.APPDATA ?? "";