gisool 0.0.0-stage → 0.1.0

package/dist/cli/main.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { ensureToken, loadConfig, resolveGisoolHome } from "../config.js";
+import { runDoctor } from "./doctor.js";
+import { runInit, serviceInstall, serviceRemove } from "./init.js";
+import { runOpen } from "./open.js";
+import { makeCliDeps, packageVersion, processIo, runServe, serviceStatus } from "./serve.js";
+const defaultLoaders = {
+    exportImport: () => import("./export-import.js"),
+    evalApi: () => import("./eval.js"),
+};
+export const HELP = `gisool - local skill router
+
+Usage:
+  gisool serve [--port <n>] [--foreground]   run the daemon in the foreground (used by the service)
+  gisool open [--print]                      print and open the dashboard URL
+  gisool init [--dry-run] [--runtime <id>...] [--no-service] [--disable-remote]
+  gisool init --rollback [--all]             undo the newest (or every) init run
+  gisool doctor [--json]                     check service, daemon, packs, index and backups
+  gisool service install|remove|status       manage the LaunchAgent / systemd user unit
+  gisool mcp-stdio                           stdio MCP proxy to the local daemon
+  gisool export <dir> [--with-history]
+  gisool import <dir> [--dry-run]
+  gisool eval [--cases <file>] [--json]
+  gisool --help | --version
+`;
+class UsageError extends Error {
+    code = "usage";
+}
+function parseArgs(args, spec) {
+    const parsed = { flags: new Set(), values: new Map(), positional: [] };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (spec.flags.includes(arg))
+            parsed.flags.add(arg);
+        else if (spec.values?.includes(arg) || spec.multi?.includes(arg)) {
+            const list = parsed.values.get(arg) ?? [];
+            const multi = spec.multi?.includes(arg);
+            let took = 0;
+            while (i + 1 < args.length && !args[i + 1].startsWith("--") && (multi || took === 0)) {
+                list.push(...args[++i].split(",").filter(Boolean));
+                took++;
+            }
+            if (took === 0)
+                throw new UsageError(`${arg} needs a value`);
+            parsed.values.set(arg, list);
+        }
+        else if (arg.startsWith("--"))
+            throw new UsageError(`unknown option ${arg}`);
+        else
+            parsed.positional.push(arg);
+    }
+    return parsed;
+}
+function oneDir(p, command) {
+    if (p.positional.length !== 1)
+        throw new UsageError(`${command} needs exactly one <dir>`);
+    return p.positional[0];
+}
+export async function runMain(argv, opts = {}) {
+    const env = opts.env ?? process.env;
+    const io = opts.io ?? processIo;
+    const loaders = opts.loaders ?? defaultLoaders;
+    const [command, ...rest] = argv;
+    try {
+        switch (command) {
+            case undefined:
+            case "--help":
+            case "-h":
+            case "help":
+                io.out(HELP);
+                return command === undefined ? 1 : 0;
+            case "--version":
+            case "-v":
+                io.out(packageVersion() + "\n");
+                return 0;
+            case "serve": {
+                const p = parseArgs(rest, { flags: ["--foreground"], values: ["--port"] });
+                const raw = p.values.get("--port")?.[0];
+                const port = raw === undefined ? undefined : Number(raw);
+                if (port !== undefined && !(Number.isInteger(port) && port > 0 && port < 65536))
+                    throw new UsageError(`invalid --port ${raw}`);
+                return await runServe({ port }, env, io);
+            }
+            case "open": {
+                const p = parseArgs(rest, { flags: ["--print"] });
+                return await runOpen({ print: p.flags.has("--print") }, env, io);
+            }
+            case "init": {
+                const p = parseArgs(rest, { flags: ["--dry-run", "--rollback", "--all", "--no-service", "--disable-remote"], multi: ["--runtime"] });
+                if (p.positional.length)
+                    throw new UsageError(`unexpected argument ${p.positional[0]}`);
+                if (p.flags.has("--all") && !p.flags.has("--rollback"))
+                    throw new UsageError("--all is only valid with --rollback");
+                return await runInit({
+                    dryRun: p.flags.has("--dry-run"), rollback: p.flags.has("--rollback"), all: p.flags.has("--all"),
+                    noService: p.flags.has("--no-service"), disableRemote: p.flags.has("--disable-remote"), runtimes: p.values.get("--runtime") ?? [],
+                }, env, io);
+            }
+            case "doctor": {
+                const p = parseArgs(rest, { flags: ["--json"] });
+                return await runDoctor({ json: p.flags.has("--json") }, env, io);
+            }
+            case "service": {
+                const [sub, ...subRest] = rest;
+                const p = parseArgs(subRest, { flags: ["--dry-run"] });
+                if (sub === "install")
+                    return await serviceInstall({ dryRun: p.flags.has("--dry-run") }, env, io);
+                if (sub === "remove")
+                    return await serviceRemove(env, io);
+                if (sub === "status")
+                    return serviceStatus(env, io);
+                throw new UsageError("service needs install, remove, or status");
+            }
+            case "mcp-stdio": {
+                parseArgs(rest, { flags: [] });
+                const config = loadConfig(env);
+                const { runStdioProxy } = await import("../mcp/stdio-proxy.js");
+                await runStdioProxy({ port: config.port, token: ensureToken(resolveGisoolHome(env)) });
+                return 0;
+            }
+            case "export": {
+                const p = parseArgs(rest, { flags: ["--with-history"] });
+                const dir = oneDir(p, "export");
+                return await (await loaders.exportImport()).runExport(dir, { withHistory: p.flags.has("--with-history") }, makeCliDeps(env));
+            }
+            case "import": {
+                const p = parseArgs(rest, { flags: ["--dry-run"] });
+                const dir = oneDir(p, "import");
+                return await (await loaders.exportImport()).runImport(dir, { dryRun: p.flags.has("--dry-run") }, makeCliDeps(env));
+            }
+            case "eval": {
+                const p = parseArgs(rest, { flags: ["--json"], values: ["--cases"] });
+                const cases = p.values.get("--cases")?.[0];
+                return await (await loaders.evalApi()).runEval({ ...(cases ? { cases } : {}), json: p.flags.has("--json") }, makeCliDeps(env));
+            }
+            default:
+                throw new UsageError(`unknown command ${command}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            io.err(`usage: ${error.message}\n\n${HELP}`);
+            return 2;
+        }
+        const code = error.code;
+        const message = error.message ?? String(error);
+        io.err(`error: ${typeof code === "string" && !message.startsWith(code) ? `${code}: ` : ""}${message}\n`);
+        return 1;
+    }
+}
+function invokedDirectly() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (invokedDirectly()) {
+    process.exitCode = await runMain(process.argv.slice(2));
+}

package/dist/cli/open.js

@@ -0,0 +1,24 @@
+import { spawn } from "node:child_process";
+import { loadConfig, ensureToken, resolveGisoolHome } from "../config.js";
+export function dashboardUrl(port, token) {
+    return `http://127.0.0.1:${port}/?token=${token}`;
+}
+export async function runOpen(opts, env, io) {
+    const config = loadConfig(env);
+    const url = dashboardUrl(config.port, ensureToken(resolveGisoolHome(env)));
+    io.out(url + "\n");
+    if (opts.print || env.GISOOL_NO_CLI)
+        return 0;
+    const opener = process.platform === "darwin" ? "open" : "xdg-open";
+    return new Promise((resolve) => {
+        const child = spawn(opener, [url], { env, stdio: "ignore", detached: true });
+        child.once("error", (error) => {
+            io.err(`could not run ${opener}: ${error.message}; open the URL above manually\n`);
+            resolve(1);
+        });
+        child.once("spawn", () => {
+            child.unref();
+            resolve(0);
+        });
+    });
+}

package/dist/cli/serve.js

@@ -0,0 +1,144 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig, resolveGisoolHome, resolveHome } from "../config.js";
+import { startServer } from "../server.js";
+import { openDb } from "../store/db.js";
+import { createStore } from "../store/index.js";
+import { readTarget } from "./config-writer.js";
+export const processIo = { out: (t) => process.stdout.write(t), err: (t) => process.stderr.write(t) };
+export const SERVICE_LABEL = "dev.gisool.daemon";
+export function packageRoot() {
+    return realpathSync(fileURLToPath(new URL("../../", import.meta.url)));
+}
+export function nodePath() {
+    return realpathSync(process.execPath);
+}
+export function packageVersion() {
+    const pkg = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8"));
+    return pkg.version;
+}
+export function dbPath(gisoolHome) {
+    return join(gisoolHome, "gisool.db");
+}
+export function makeCliDeps(env) {
+    const config = loadConfig(env);
+    const home = resolveHome(env);
+    const gisoolHome = resolveGisoolHome(env);
+    return { config, home, gisoolHome, env, openStore: () => createStore(openDb(dbPath(gisoolHome)), { config, home, gisoolHome }) };
+}
+export async function runServe(opts, env, io) {
+    const deps = makeCliDeps(env);
+    const config = opts.port === undefined ? deps.config : { ...deps.config, port: opts.port };
+    const server = await startServer(config, { gisoolHome: deps.gisoolHome, openStore: deps.openStore });
+    io.err(`gisool listening on http://127.0.0.1:${server.port}\n`);
+    return 0;
+}
+const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const unitQuote = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+export function servicePath(home, platform) {
+    return platform === "darwin"
+        ? join(home, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`)
+        : join(home, ".config", "systemd", "user", "gisool.service");
+}
+export function daemonLogPath(gisoolHome) {
+    return join(gisoolHome, "logs", "daemon.log");
+}
+function plist(ctx) {
+    const log = xml(daemonLogPath(ctx.gisoolHome));
+    const args = [ctx.nodePath, join(ctx.packageRoot, "dist", "cli", "main.js"), "serve"].map((a) => `    <string>${xml(a)}</string>`).join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>GISOOL_HOME</key>
+    <string>${xml(ctx.gisoolHome)}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${log}</string>
+  <key>StandardErrorPath</key>
+  <string>${log}</string>
+</dict>
+</plist>
+`;
+}
+function unit(ctx) {
+    const log = daemonLogPath(ctx.gisoolHome);
+    return `[Unit]
+Description=gisool local skill router
+
+[Service]
+ExecStart=${unitQuote(ctx.nodePath)} ${unitQuote(join(ctx.packageRoot, "dist", "cli", "main.js"))} serve
+Environment=${unitQuote(`GISOOL_HOME=${ctx.gisoolHome}`)}
+Restart=always
+StandardOutput=append:${log}
+StandardError=append:${log}
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function planService(ctx) {
+    const path = servicePath(ctx.home, ctx.platform);
+    const before = readTarget(path);
+    const after = ctx.platform === "darwin" ? plist(ctx) : unit(ctx);
+    const file = { path, before, after, mode: 0o644 };
+    const commands = [];
+    const notes = [];
+    if (before === after)
+        return { file, commands, notes: ["service definition already up to date"] };
+    if (ctx.platform === "darwin") {
+        const domain = `gui/${ctx.uid}`;
+        if (before !== null)
+            commands.push({ argv: ["launchctl", "bootout", `${domain}/${SERVICE_LABEL}`], description: "Unload the previous gisool LaunchAgent", allowFailure: true });
+        commands.push({ argv: ["launchctl", "bootstrap", domain, path], description: "Load the gisool LaunchAgent",
+            undo: { argv: ["launchctl", "bootout", `${domain}/${SERVICE_LABEL}`], description: "Unload the gisool LaunchAgent" } });
+    }
+    else {
+        commands.push({ argv: ["systemctl", "--user", "daemon-reload"], description: "Reload systemd user units" });
+        commands.push({ argv: ["systemctl", "--user", "enable", "--now", "gisool.service"], description: "Enable and start the gisool user service",
+            undo: { argv: ["systemctl", "--user", "disable", "--now", "gisool.service"], description: "Stop and disable the gisool user service" } });
+        if (before !== null)
+            commands.push({ argv: ["systemctl", "--user", "restart", "gisool.service"], description: "Restart gisool with the new unit" });
+    }
+    if (ctx.env.GISOOL_NO_CLI) {
+        notes.push(`GISOOL_NO_CLI set: service file written but not loaded; run manually: ${commands.map((c) => c.argv.join(" ")).join(" && ")}`);
+        return { file, commands: [], notes };
+    }
+    return { file, commands, notes };
+}
+export function serviceLoaded(platform, uid, env) {
+    const argv = platform === "darwin" ? ["launchctl", "print", `gui/${uid}/${SERVICE_LABEL}`] : ["systemctl", "--user", "is-active", "gisool"];
+    const r = spawnSync(argv[0], argv.slice(1), { env, stdio: "ignore" });
+    return r.status === 0;
+}
+export function currentServicePlatform() {
+    return process.platform === "darwin" ? "darwin" : "linux";
+}
+export function serviceStatus(env, io) {
+    const home = resolveHome(env);
+    const platform = currentServicePlatform();
+    const path = servicePath(home, platform);
+    const installed = existsSync(path);
+    io.out(`service file: ${installed ? path : "not installed"}\n`);
+    if (env.GISOOL_NO_CLI) {
+        io.out("service loaded: skipped (GISOOL_NO_CLI)\n");
+        return installed ? 0 : 1;
+    }
+    const loaded = serviceLoaded(platform, process.getuid?.() ?? 0, env);
+    io.out(`service loaded: ${loaded ? "yes" : "no"}\n`);
+    return installed && loaded ? 0 : 1;
+}

package/dist/config.js

@@ -0,0 +1,78 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+export const DEFAULT_PORT = 8799;
+export const DEFAULT_ROOTS = [
+    { id: "agents", path: "~/.agents/skills" },
+    { id: "claude", path: "~/.claude/skills" },
+    { id: "codex", path: "~/.codex/skills" },
+    { id: "gemini", path: "~/.gemini/skills" },
+    { id: "omo", path: "~/.omo/agent/skills" },
+    { id: "gajae", path: "~/.gjc/agent/skills" },
+    { id: "openclaw", path: "~/.openclaw/skills" },
+    { id: "gisul", path: "~/gisul/skills" },
+];
+const runtimeIds = ["claude-code", "codex", "gemini", "cursor", "omo", "gajae", "openclaw", "unknown"];
+const fileSchema = z.object({
+    port: z.number().int().min(1).max(65535).optional(),
+    captureLevel: z.enum(["metadata", "redacted", "full"]).optional(),
+    retentionDays: z.number().int().positive().nullable().optional(),
+    roots: z.array(z.object({ id: z.string().min(1), path: z.string().min(1) })).optional(),
+    runtimes: z.partialRecord(z.enum(runtimeIds), z.object({ enabled: z.boolean() })).optional(),
+});
+export function resolveHome(env) {
+    return env.HOME && env.HOME.length > 0 ? env.HOME : homedir();
+}
+export function resolveGisoolHome(env) {
+    return env.GISOOL_HOME && env.GISOOL_HOME.length > 0 ? env.GISOOL_HOME : join(resolveHome(env), ".gisool");
+}
+export function expandHome(path, home) {
+    if (path === "~")
+        return home;
+    if (path.startsWith("~/"))
+        return join(home, path.slice(2));
+    return isAbsolute(path) ? path : join(home, path);
+}
+export function defaultConfigFile() {
+    return { port: DEFAULT_PORT, captureLevel: "full", retentionDays: null, roots: DEFAULT_ROOTS.map((r) => ({ ...r })), runtimes: {} };
+}
+export function ensureGisoolHome(env) {
+    const dir = resolveGisoolHome(env);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    return dir;
+}
+/** Returns the daemon bearer token, creating a 32-byte hex token (mode 0600) on first use. */
+export function ensureToken(gisoolHome) {
+    const path = join(gisoolHome, "token");
+    if (existsSync(path)) {
+        const token = readFileSync(path, "utf8").trim();
+        if (/^[0-9a-f]{64}$/.test(token))
+            return token;
+    }
+    const token = randomBytes(32).toString("hex");
+    writeFileSync(path, token + "\n", { mode: 0o600 });
+    chmodSync(path, 0o600);
+    return token;
+}
+/** Loads (and on first run creates) GISOOL_HOME, config.json and the token. No work happens at import time. */
+export function loadConfig(env) {
+    const home = resolveHome(env);
+    const gisoolHome = ensureGisoolHome(env);
+    const configPath = join(gisoolHome, "config.json");
+    if (!existsSync(configPath)) {
+        writeFileSync(configPath, JSON.stringify(defaultConfigFile(), null, 2) + "\n", { mode: 0o600 });
+    }
+    const parsed = fileSchema.parse(JSON.parse(readFileSync(configPath, "utf8")));
+    ensureToken(gisoolHome);
+    const defaults = defaultConfigFile();
+    return {
+        port: parsed.port ?? defaults.port,
+        captureLevel: parsed.captureLevel ?? defaults.captureLevel,
+        retentionDays: parsed.retentionDays ?? null,
+        roots: (parsed.roots ?? defaults.roots).map((r) => ({ id: r.id, path: expandHome(r.path, home) })),
+        runtimes: parsed.runtimes ?? {},
+    };
+}