@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/web.js

@@ -1,132 +1,212 @@
-import { existsSync, } from "node:fs";
-import { resolve } from "node:path";
+/**
+ * `interf web` — start the engine in the foreground until Ctrl-C.
+ *
+ *   interf web                # start on default port; hard error if port busy
+ *   interf web stop           # send SIGTERM to the running engine
+ *   interf web status         # print engine info via the connected URL
+ *
+ * Pure server. No reuse / register-with-existing logic. Writes
+ * `~/.interf/connection.json` on startup so subsequent CLI commands can
+ * connect without a pointer file.
+ */
 import chalk from "chalk";
-import { startLocalService, } from "../../packages/local-service/index.js";
-import { createNativeLocalServiceRunHandlers, } from "../../packages/local-service/native-run-handlers.js";
-import { loadSourceFolderConfig, saveSourceFolderConfig, sourceFolderConfigPath, } from "../../packages/project-model/source-config.js";
-import { seedLocalDefaultMethod } from "../../packages/method-package/local-methods.js";
-import { findNearestInterfInstanceConfig, hasInterfInstanceConfig, relativeSourceFolderPath, resolveInterfInstanceContext, } from "./control-path.js";
-import { listSourceFolderChoices, } from "../../packages/project-model/source-folders.js";
-export const webCommand = {
-    command: "web",
-    describe: "Start Interf Compiler UI and the local Interf service",
-    builder: (yargs) => yargs
-        .option("host", {
-        type: "string",
-        describe: "Host for the local Interf service",
-    })
-        .option("port", {
-        type: "number",
-        describe: "Port for the local Interf service",
-    })
-        .option("control-path", {
-        type: "string",
-        describe: "Folder where Interf stores local config, Methods, runs, and portable context",
-    })
-        .option("source-folder", {
-        type: "string",
-        describe: "Source Folder to prepare when initializing a new Interf Workspace",
-    }),
-    handler: async (argv) => {
-        await runWebCommand(argv);
-    },
-};
-function stringOption(value) {
-    return typeof value === "string" && value.trim().length > 0
-        ? value.trim()
-        : undefined;
-}
-function numberOption(value) {
-    if (typeof value !== "number" || !Number.isInteger(value))
+import { readFileSync } from "node:fs";
+import { LOCAL_SERVICE_DEFAULT_HOST, LOCAL_SERVICE_DEFAULT_PORT, buildLocalServiceUrl, } from "../../packages/engine/routes.js";
+import { startLocalService } from "../../packages/engine/server.js";
+import { createNativeLocalServiceRunHandlers } from "../../packages/engine/native-run-handlers.js";
+import { CONNECT_OR_ERROR_HINT, clearConnection, readActiveConnection, } from "../../packages/engine/connection-config.js";
+import { serviceRegistryPath } from "../../packages/engine/instance-paths.js";
+function packageVersionFromManifest() {
+    try {
+        const url = new URL("../../../package.json", import.meta.url);
+        const raw = readFileSync(url, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed.version;
+    }
+    catch {
         return undefined;
-    return value;
+    }
 }
-export function resolveWebProjectPaths(argv = {}, cwd = process.cwd()) {
-    const currentPath = resolve(cwd);
-    const configuredControlPath = stringOption(argv["control-path"]);
-    const configuredSourceFolder = stringOption(argv["source-folder"]);
-    if (configuredControlPath) {
-        return {
-            controlPath: resolve(currentPath, configuredControlPath),
-            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
-        };
-    }
-    const existingControlPath = findNearestInterfInstanceConfig(currentPath);
-    if (existingControlPath) {
-        return {
-            controlPath: existingControlPath,
-            sourceFolderPath: configuredSourceFolder ? resolve(currentPath, configuredSourceFolder) : null,
-        };
-    }
-    if (configuredSourceFolder) {
-        const resolvedSourceFolder = resolve(currentPath, configuredSourceFolder);
-        const context = resolveInterfInstanceContext(resolvedSourceFolder);
-        return {
-            controlPath: context.controlPath,
-            sourceFolderPath: resolvedSourceFolder,
-        };
-    }
-    const context = resolveInterfInstanceContext(currentPath);
-    return {
-        controlPath: context.controlPath,
-        sourceFolderPath: context.defaultSourceFolderPath ?? currentPath,
-    };
+function isPortInUseError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const code = error.code;
+    return code === "EADDRINUSE";
 }
-export function ensureWebProjectInitialized(controlPath, options = {}) {
-    const inferSourceFolderPath = () => {
-        if (options.sourceFolderPath)
-            return options.sourceFolderPath;
-        const choices = listSourceFolderChoices(controlPath);
-        return choices.length === 1 ? resolve(controlPath, choices[0]?.value ?? "") : null;
-    };
-    if (existsSync(sourceFolderConfigPath(controlPath))) {
-        if (!hasInterfInstanceConfig(controlPath)) {
-            throw new Error(`Interf Workspace path is not usable: ${sourceFolderConfigPath(controlPath)}. Choose a different --control-path.`);
+async function runWebForeground(args) {
+    const host = args.host ?? LOCAL_SERVICE_DEFAULT_HOST;
+    const port = args.port ?? LOCAL_SERVICE_DEFAULT_PORT;
+    let service;
+    try {
+        service = await startLocalService({
+            host,
+            port,
+            packageVersion: packageVersionFromManifest(),
+            handlers: createNativeLocalServiceRunHandlers(),
+        });
+    }
+    catch (error) {
+        if (isPortInUseError(error)) {
+            console.error(chalk.red(`Error: another Interf engine is already running at ${buildLocalServiceUrl({ host, port })}.`));
+            console.error(`Stop it first with \`interf web stop\`.`);
+            process.exit(1);
         }
-        const existing = loadSourceFolderConfig(controlPath);
-        const sourceFolderPath = existing?.source_folder ? null : inferSourceFolderPath();
-        if (existing && sourceFolderPath) {
-            saveSourceFolderConfig(controlPath, {
-                source_folder: {
-                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
-                },
-                preparations: existing.preparations ?? [],
-            });
+        throw error;
+    }
+    console.log();
+    console.log(`  Interf engine: ${chalk.bold(service.url)}`);
+    console.log(`  Compiler UI:   ${service.url}/`);
+    console.log(`  Health:        ${service.url}/health`);
+    console.log(chalk.dim("  Press Ctrl-C to stop."));
+    console.log();
+    const shutdown = async () => {
+        try {
+            await service.close();
         }
-        return;
-    }
-    seedLocalDefaultMethod({ sourcePath: controlPath });
-    const sourceFolderPath = inferSourceFolderPath();
-    saveSourceFolderConfig(controlPath, {
-        ...(sourceFolderPath
-            ? {
-                source_folder: {
-                    path: relativeSourceFolderPath(controlPath, sourceFolderPath),
-                },
-            }
-            : {}),
-        preparations: [],
+        catch {
+            // best effort
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await new Promise(() => {
+        /* block forever; signals trigger shutdown */
     });
 }
-export async function runWebCommand(argv = {}) {
-    const { controlPath, sourceFolderPath } = resolveWebProjectPaths(argv);
-    ensureWebProjectInitialized(controlPath, { sourceFolderPath });
-    const handlers = createNativeLocalServiceRunHandlers();
-    const service = await startLocalService({
-        rootPath: controlPath,
-        host: stringOption(argv.host),
-        port: numberOption(argv.port),
-        handlers,
+function findEnginePidByUrl(url) {
+    try {
+        const raw = readFileSync(serviceRegistryPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        const entry = parsed.services?.find((s) => s.url === url);
+        return entry?.pid ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isPidAlive(pid) {
+    try {
+        // Signal 0 is a no-op probe — succeeds if the PID exists and we can
+        // signal it; throws ESRCH otherwise.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Scan ~/.interf/services.json for engines whose PID is still alive.
+ * Used by `interf web stop` when ~/.interf/connection.json is missing
+ * — the registry tells us which engine processes are actually running
+ * regardless of which one the wizard last connected to.
+ */
+function listLiveEnginesFromRegistry() {
+    try {
+        const raw = readFileSync(serviceRegistryPath(), "utf8");
+        const parsed = JSON.parse(raw);
+        return (parsed.services ?? []).filter((entry) => typeof entry.pid === "number" && isPidAlive(entry.pid));
+    }
+    catch {
+        return [];
+    }
+}
+async function runWebStop(args) {
+    // Resolution order: explicit --url override → active connection.json
+    // → fall back to scanning services.json for any live engine. The
+    // last fallback recovers from the case where connection.json was
+    // cleared while an engine was still running (e.g. another `interf
+    // web` attempt failed mid-startup, or `interf logout` was run while
+    // the engine kept going).
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
     });
-    console.log(chalk.green(`  Interf Compiler service: ${service.url}`));
-    console.log(chalk.dim(`  Compiler UI: ${service.url}/`));
-    console.log(chalk.dim(`  Health: ${service.url}/health`));
-    console.log(chalk.dim("  Press Ctrl-C to stop the local Interf service."));
-    await new Promise((resolve) => {
-        const shutdown = () => {
-            void service.close().finally(resolve);
-        };
-        process.once("SIGINT", shutdown);
-        process.once("SIGTERM", shutdown);
+    let urlToStop = conn ? conn.url.replace(/\/+$/, "") : null;
+    let pidToStop = urlToStop ? findEnginePidByUrl(urlToStop) : null;
+    if (!pidToStop) {
+        const liveEngines = listLiveEnginesFromRegistry();
+        if (liveEngines.length === 0) {
+            console.error("No live Interf engine to stop.");
+            console.error("Checked ~/.interf/connection.json and ~/.interf/services.json — neither pointed at a running process.");
+            process.exit(1);
+        }
+        if (liveEngines.length > 1 && !urlToStop) {
+            console.error(`Multiple live Interf engines registered. Pick one with --url:`);
+            for (const entry of liveEngines) {
+                console.error(`  ${entry.url} (pid ${entry.pid})`);
+            }
+            process.exit(1);
+        }
+        const target = urlToStop
+            ? liveEngines.find((entry) => entry.url === urlToStop)
+            : liveEngines[0];
+        if (!target) {
+            console.error(`No live engine matches ${urlToStop ?? "the active connection"} in services.json.`);
+            process.exit(1);
+        }
+        urlToStop = target.url;
+        pidToStop = target.pid;
+        if (!conn) {
+            console.log(chalk.dim(`  No active connection.json — recovering engine pid ${pidToStop} from services.json.`));
+        }
+    }
+    try {
+        process.kill(pidToStop, "SIGTERM");
+        console.log(chalk.green(`Sent SIGTERM to engine pid ${pidToStop} (${urlToStop}).`));
+        if (conn)
+            clearConnection();
+    }
+    catch (error) {
+        console.error(`Failed to stop engine pid ${pidToStop}: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+async function runWebStatus(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
     });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    const url = conn.url.replace(/\/+$/, "");
+    try {
+        const headers = new Headers();
+        if (conn.auth_token)
+            headers.set("authorization", `Bearer ${conn.auth_token}`);
+        const response = await fetch(`${url}/v1/instance`, { headers });
+        const raw = await response.text();
+        if (response.status !== 200) {
+            console.error(chalk.red(`Engine status request failed (HTTP ${response.status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(raw);
+    }
+    catch (error) {
+        console.error(chalk.red(`Engine ${url} unreachable: ${error instanceof Error ? error.message : String(error)}`));
+        process.exit(1);
+    }
 }
+export const webCommand = {
+    command: "web [subcommand]",
+    describe: "Start / stop / inspect the Interf engine",
+    builder: (yargs) => yargs
+        .command("stop", "Stop the connected engine", (y) => y
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }), runWebStop)
+        .command("status", "Show engine status via the connected URL", (y) => y
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }), runWebStatus)
+        .command("$0", "Start the engine in the foreground (default)", (y) => y
+        .option("host", { type: "string", default: LOCAL_SERVICE_DEFAULT_HOST, describe: "Host to bind" })
+        .option("port", { type: "number", default: LOCAL_SERVICE_DEFAULT_PORT, describe: "Port to bind" }), runWebForeground)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

package/dist/cli/commands/wizard.d.ts

@@ -0,0 +1,9 @@
+import type { CommandModule } from "yargs";
+interface WizardArgs {
+    url?: string;
+    token?: string;
+}
+export declare const wizardCommand: CommandModule<unknown, WizardArgs>;
+/** Alias: `interf init` runs the same wizard. */
+export declare const initCommand: CommandModule<unknown, WizardArgs>;
+export {};