@numairbaseer/scifcode 0.1.6 → 0.3.0

package/src/cli.js

@@ -1,9 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { ensureScifcodeConfig } from "./ensure-scifcode-config.js";
 import { loadScifcodeEnv } from "./env-config.js";
 import { runRuntime } from "./run-runtime.js";
+import { login, logout, whoami } from "./control-plane-auth.js";
+import packageJson from "../package.json" with { type: "json" };
 
 export function printHelp(stdout = console.log) {
   stdout(`Scifcode - coding CLI agent powered by Poolside Laguna
@@ -11,11 +10,13 @@ export function printHelp(stdout = console.log) {
 Usage:
   scifcode                 Start interactive coding agent
   scifcode -p "prompt"     Run one-shot prompt
-
-Required environment:
-  SCIFCODE_API_KEY        API key or bearer token for the configured endpoint
+  scifcode login [--control-plane <url>]
+                           Authenticate in the portal and start Scifcode
+  scifcode logout          Revoke the current CLI session
+  scifcode whoami          Show the authenticated user
 
 Optional environment:
+  SCIFCODE_CONTROL_PLANE_URL  Control-plane origin (default: http://localhost:8080)
   SCIFCODE_RUNTIME_BIN     Path to a compiled Scifcode runtime binary
   SCIFCODE_SOURCE_DIR      Path to the Scifcode OpenCode fork
   SCIFCODE_BUN_BIN         Path to Bun when launching the fork from source
@@ -27,11 +28,7 @@ Private config files:
 }
 
 export function getPackageVersion() {
-  const currentFile = fileURLToPath(import.meta.url);
-  const srcDir = path.dirname(currentFile);
-  const packagePath = path.join(srcDir, "..", "package.json");
-  const pkg = JSON.parse(fs.readFileSync(packagePath, "utf8"));
-  return pkg.version;
+  return packageJson.version;
 }
 
 function createConsoleWriters(stdout, stderr) {
@@ -45,7 +42,31 @@ function createConsoleWriters(stdout, stderr) {
   };
 }
 
-export function main(options = {}) {
+export function parseLoginControlPlaneUrl(args = []) {
+  const loginArgs = args.slice(1);
+  let controlPlaneUrl;
+  for (let index = 0; index < loginArgs.length; index += 1) {
+    const argument = loginArgs[index];
+    let value;
+    if (argument === "--control-plane") {
+      value = loginArgs[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new Error("--control-plane requires a URL.");
+      }
+      index += 1;
+    } else if (argument.startsWith("--control-plane=")) {
+      value = argument.slice("--control-plane=".length);
+      if (!value) throw new Error("--control-plane requires a URL.");
+    } else {
+      throw new Error(`Unknown login option: ${argument}`);
+    }
+    if (controlPlaneUrl) throw new Error("Specify --control-plane only once.");
+    controlPlaneUrl = value;
+  }
+  return controlPlaneUrl;
+}
+
+export async function main(options = {}) {
   const args = options.args || process.argv.slice(2);
   const command = args[0];
   const baseEnv = options.env || process.env;
@@ -66,6 +87,16 @@ export function main(options = {}) {
     options.stderr || console.error
   );
 
+  const authOptions = {
+    env,
+    homeDir: options.homeDir,
+    stdout: writers.log,
+    input: options.input,
+    output: options.output,
+    question: options.question,
+    fetchFn: options.fetchFn
+  };
+
   if (command === "--help" || command === "-h") {
     printHelp(writers.log);
     exit(0);
@@ -78,13 +109,43 @@ export function main(options = {}) {
     return;
   }
 
+  let runtimeArgs = args;
+  try {
+    if (command === "login") {
+      await (options.loginFn || login)({
+        ...authOptions,
+        controlPlaneUrl: parseLoginControlPlaneUrl(args)
+      });
+      runtimeArgs = [];
+    }
+    else if (command === "logout") {
+      await (options.logoutFn || logout)(authOptions);
+      writers.log("Logged out.");
+      exit(0);
+      return;
+    }
+    else if (command === "whoami") {
+      const identity = await (options.whoamiFn || whoami)(authOptions);
+      writers.log(identity.user.email);
+      writers.log(`Role: ${identity.user.role}`);
+      writers.log(`Session expires: ${identity.expiresAt}`);
+      writers.log(`Control plane: ${identity.controlPlaneUrl}`);
+      exit(0);
+      return;
+    }
+  } catch (error) {
+    writers.error(error.message);
+    exit(1);
+    return;
+  }
+
   try {
-    ensureScifcodeConfigFn({ env });
+    ensureScifcodeConfigFn({ env, homeDir: options.homeDir });
   } catch (error) {
     writers.error(error.message);
     exit(1);
     return;
   }
 
-  runRuntimeFn(args, { env, exit, stderr: writers.error });
+  runRuntimeFn(runtimeArgs, { env, exit, stderr: writers.error, homeDir: options.homeDir });
 }

package/src/code-usage.js

@@ -0,0 +1,86 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+function runGit(args, options = {}) {
+  const result = (options.spawnSyncFn || spawnSync)("git", args, {
+    cwd: options.cwd,
+    env: options.env,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(String(result.stderr || "Git command failed.").trim());
+  }
+  return String(result.stdout || "").trim();
+}
+
+function snapshotWorkingTree(repoDir, options = {}) {
+  const temporaryDir = fs.mkdtempSync(path.join(options.tmpDir || os.tmpdir(), "scifcode-git-index-"));
+  const indexPath = path.join(temporaryDir, "index");
+  const env = { ...(options.env || process.env), GIT_INDEX_FILE: indexPath };
+  try {
+    try {
+      runGit(["read-tree", "HEAD"], { ...options, cwd: repoDir, env });
+    } catch {
+      runGit(["read-tree", "--empty"], { ...options, cwd: repoDir, env });
+    }
+    runGit(["add", "-A"], { ...options, cwd: repoDir, env });
+    return runGit(["write-tree"], { ...options, cwd: repoDir, env });
+  } finally {
+    fs.rmSync(temporaryDir, { recursive: true, force: true });
+  }
+}
+
+function countChangedLines(numstat) {
+  return numstat.split("\n").reduce((total, line) => {
+    if (!line) return total;
+    const [added, deleted] = line.split("\t");
+    const additions = Number.parseInt(added, 10);
+    const deletions = Number.parseInt(deleted, 10);
+    return total
+      + (Number.isNaN(additions) ? 0 : additions)
+      + (Number.isNaN(deletions) ? 0 : deletions);
+  }, 0);
+}
+
+export function createCodeUsageReporter(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  let repoDir;
+  let startingTree;
+  try {
+    repoDir = runGit(["rev-parse", "--show-toplevel"], { ...options, cwd });
+    startingTree = snapshotWorkingTree(repoDir, options);
+  } catch {
+    return null;
+  }
+
+  const eventId = (options.randomUUIDFn || crypto.randomUUID)();
+  return {
+    eventId,
+    async report() {
+      const endingTree = snapshotWorkingTree(repoDir, options);
+      const numstat = runGit(["diff", "--no-ext-diff", "--numstat", startingTree, endingTree], {
+        ...options,
+        cwd: repoDir,
+        env: options.env || process.env
+      });
+      const linesChanged = countChangedLines(numstat);
+      const response = await (options.fetchFn || fetch)(`${options.controlPlaneUrl}/usage/code`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${options.sessionToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ eventId, linesChanged })
+      });
+      if (!response.ok) {
+        throw new Error(`Control-plane request failed: HTTP ${response.status}`);
+      }
+      return { eventId, linesChanged };
+    }
+  };
+}

package/src/constants.js

@@ -1,8 +1,31 @@
 export const DEFAULT_PROVIDER_NAME = "scifcode";
-export const DEFAULT_BASE_URL = "https://danishshaik--reservoir-vllm-serve.modal.run/v1";
-export const DEFAULT_MODEL = "scifcode-1.0";
-export const DEFAULT_MODEL_NAME = "scifcode-1.0";
+export const DEFAULT_CONTROL_PLANE_URL = "http://localhost:8080";
+export const DEFAULT_MODEL = "scifcoder-1.0";
+export const DEFAULT_MODEL_NAME = "scifcoder-1.0";
 export const DEFAULT_CONTEXT_WINDOW = 32768;
 export const DEFAULT_MAX_TOKENS = 8192;
-export const API_KEY_ENV_NAME = "SCIFCODE_API_KEY";
-export const LEGACY_API_KEY_ENV_NAME = "LAGUNA_API_KEY";
+export const SESSION_TOKEN_ENV_NAME = "SCIFCODE_SESSION_TOKEN";
+
+export function normalizeControlPlaneUrl(value) {
+  const normalized = String(value || "").trim();
+  let url;
+  try {
+    url = new URL(normalized);
+  } catch {
+    throw new Error(`Invalid control-plane URL: ${normalized}`);
+  }
+  const local = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "[::1]";
+  if (url.protocol !== "https:" && !(local && url.protocol === "http:")) {
+    throw new Error("The control-plane URL must use HTTPS except on localhost.");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+
+export function getControlPlaneUrl(env = process.env) {
+  const value = String(env.SCIFCODE_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL).trim();
+  return normalizeControlPlaneUrl(value);
+}
+
+export function getModelBaseUrl(env = process.env) {
+  return `${getControlPlaneUrl(env)}/v1`;
+}

package/src/control-plane-auth.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+import { getControlPlaneUrl, normalizeControlPlaneUrl } from "./constants.js";
+import { getScifcodeHomeDir, getScifcodeSessionPath } from "./paths.js";
+
+async function requestJson(fetchFn, url, options = {}) {
+  let response;
+  try {
+    response = await fetchFn(url, options);
+  } catch (error) {
+    throw new Error(`Could not reach the Scifcode control plane. ${error.message}`);
+  }
+  const text = await response.text();
+  let body = {};
+  try { body = text ? JSON.parse(text) : {}; } catch {}
+  if (!response.ok) {
+    const reason = body.error || body.message || `HTTP ${response.status}`;
+    const error = new Error(`Control-plane request failed: ${reason}`);
+    error.status = response.status;
+    error.code = body.error;
+    throw error;
+  }
+  return body;
+}
+
+export function readSession(options = {}) {
+  const sessionPath = options.sessionPath || getScifcodeSessionPath(options.homeDir);
+  if (!fs.existsSync(sessionPath)) return null;
+  try {
+    const session = JSON.parse(fs.readFileSync(sessionPath, "utf8"));
+    if (!session.sessionToken || !session.controlPlaneUrl) return null;
+    return session;
+  } catch {
+    throw new Error(`Scifcode could not parse ${sessionPath}. Run \`scifcode login\` again.`);
+  }
+}
+
+export function writeSession(session, options = {}) {
+  const homeDir = options.homeDir;
+  const directory = options.sessionDir || getScifcodeHomeDir(homeDir);
+  const sessionPath = options.sessionPath || getScifcodeSessionPath(homeDir);
+  fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  fs.chmodSync(directory, 0o700);
+  const temporaryPath = `${sessionPath}.${process.pid}.tmp`;
+  fs.writeFileSync(temporaryPath, `${JSON.stringify(session, null, 2)}\n`, { mode: 0o600 });
+  fs.renameSync(temporaryPath, sessionPath);
+  fs.chmodSync(sessionPath, 0o600);
+  return sessionPath;
+}
+
+export function deleteSession(options = {}) {
+  const sessionPath = options.sessionPath || getScifcodeSessionPath(options.homeDir);
+  if (fs.existsSync(sessionPath)) fs.unlinkSync(sessionPath);
+}
+
+export function openBrowser(url, options = {}) {
+  const platform = options.platform || process.platform;
+  const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd.exe" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = (options.spawnFn || spawn)(command, args, {
+    stdio: "ignore",
+    detached: true
+  });
+  child.on?.("error", () => {});
+  child.unref?.();
+}
+
+export async function login(options = {}) {
+  const fetchFn = options.fetchFn || fetch;
+  const stdout = options.stdout || console.log;
+  const controlPlaneUrl = normalizeControlPlaneUrl(
+    options.controlPlaneUrl || getControlPlaneUrl(options.env)
+  );
+  const authorization = await requestJson(fetchFn, `${controlPlaneUrl}/auth/device/request`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: "{}"
+  });
+  if (!authorization.deviceCode || !authorization.verificationUriComplete) {
+    throw new Error("The control plane returned an invalid device authorization.");
+  }
+
+  stdout("Authenticate Scifcode in your browser:");
+  stdout(authorization.verificationUriComplete);
+  try {
+    (options.openBrowserFn || openBrowser)(authorization.verificationUriComplete);
+  } catch {}
+
+  const now = options.nowFn || Date.now;
+  const sleep = options.sleepFn || (milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds)));
+  const interval = Math.max(Number(authorization.interval) || 2, 1) * 1000;
+  const deadline = now() + Math.max(Number(authorization.expiresIn) || 600, 1) * 1000;
+  let verified;
+  while (now() < deadline) {
+    await sleep(interval);
+    try {
+      verified = await requestJson(fetchFn, `${controlPlaneUrl}/auth/device/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceCode: authorization.deviceCode })
+      });
+      break;
+    } catch (error) {
+      if (error.code === "authorization_pending") continue;
+      throw error;
+    }
+  }
+  if (!verified?.sessionToken) {
+    throw new Error("CLI authorization expired. Run `scifcode login` again.");
+  }
+  const session = {
+    sessionToken: verified.sessionToken,
+    email: verified.user?.email,
+    expiresAt: verified.expiresAt,
+    controlPlaneUrl
+  };
+  writeSession(session, options);
+  stdout(`Logged in as ${session.email}.`);
+  return session;
+}
+
+export async function whoami(options = {}) {
+  const session = readSession(options);
+  if (!session) throw new Error("Not logged in. Run `scifcode login`.");
+  const result = await requestJson(options.fetchFn || fetch, `${session.controlPlaneUrl}/auth/me`, {
+    headers: { authorization: `Bearer ${session.sessionToken}` }
+  });
+  return { ...result, controlPlaneUrl: session.controlPlaneUrl };
+}
+
+export async function logout(options = {}) {
+  const session = readSession(options);
+  try {
+    if (session) {
+      await requestJson(options.fetchFn || fetch, `${session.controlPlaneUrl}/auth/logout`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${session.sessionToken}` }
+      });
+    }
+  } finally {
+    deleteSession(options);
+  }
+}

package/src/ensure-scifcode-config.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
-import { API_KEY_ENV_NAME, DEFAULT_BASE_URL, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_MODEL, DEFAULT_MODEL_NAME, DEFAULT_PROVIDER_NAME, LEGACY_API_KEY_ENV_NAME } from "./constants.js";
+import { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_MODEL, DEFAULT_MODEL_NAME, DEFAULT_PROVIDER_NAME, SESSION_TOKEN_ENV_NAME, getModelBaseUrl, normalizeControlPlaneUrl } from "./constants.js";
+import { readSession } from "./control-plane-auth.js";
 import { getScifcodeConfigDir, getScifcodeConfigPath } from "./paths.js";
 
 function positiveInteger(value, fallback) {
@@ -19,19 +20,16 @@ export function buildScifcodeModels(env = process.env) {
   };
 }
 
-export function getApiKeyReference(env = process.env) {
-  return env[LEGACY_API_KEY_ENV_NAME] && !env[API_KEY_ENV_NAME]
-    ? `{env:${LEGACY_API_KEY_ENV_NAME}}`
-    : `{env:${API_KEY_ENV_NAME}}`;
-}
-
-export function buildScifcodeProvider(env = process.env) {
+export function buildScifcodeProvider(env = process.env, options = {}) {
+  const baseURL = options.controlPlaneUrl
+    ? `${normalizeControlPlaneUrl(options.controlPlaneUrl)}/v1`
+    : getModelBaseUrl(env);
   return {
     npm: "@ai-sdk/openai-compatible",
     name: "Scifcode",
     options: {
-      baseURL: DEFAULT_BASE_URL,
-      apiKey: getApiKeyReference(env)
+      baseURL,
+      apiKey: `{env:${SESSION_TOKEN_ENV_NAME}}`
     },
     models: buildScifcodeModels(env)
   };
@@ -49,7 +47,10 @@ export function ensureScifcodeConfig(options = {}) {
   const configPath = getScifcodeConfigPath(options.homeDir);
   const providerName = DEFAULT_PROVIDER_NAME;
   const existing = readConfig(configPath);
-  const provider = buildScifcodeProvider(env);
+  const session = (options.readSessionFn || readSession)({ homeDir: options.homeDir });
+  const provider = buildScifcodeProvider(env, {
+    controlPlaneUrl: session?.controlPlaneUrl || env.SCIFCODE_CONTROL_PLANE_URL
+  });
   const merged = {
     ...existing,
     $schema: existing.$schema || "https://opencode.ai/config.json",

package/src/paths.js

@@ -3,6 +3,7 @@ import path from "node:path";
 
 export function getScifcodeHomeDir(homeDir = os.homedir()) { return path.join(homeDir, ".scifcode"); }
 export function getScifcodeEnvPath(homeDir = os.homedir()) { return path.join(getScifcodeHomeDir(homeDir), "env"); }
+export function getScifcodeSessionPath(homeDir = os.homedir()) { return path.join(getScifcodeHomeDir(homeDir), "session.json"); }
 export function getProjectScifcodeEnvPath(cwd = process.cwd()) { return path.join(cwd, ".scifcode.env"); }
 export function getScifcodeConfigDir(homeDir = os.homedir()) { return path.join(homeDir, ".config", "scifcode"); }
 export function getScifcodeConfigPath(homeDir = os.homedir()) { return path.join(getScifcodeConfigDir(homeDir), "scifcode.json"); }

package/src/run-runtime.js

@@ -3,7 +3,9 @@ import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { API_KEY_ENV_NAME, DEFAULT_MODEL, DEFAULT_PROVIDER_NAME, LEGACY_API_KEY_ENV_NAME } from "./constants.js";
+import { DEFAULT_MODEL, DEFAULT_PROVIDER_NAME, SESSION_TOKEN_ENV_NAME, getControlPlaneUrl } from "./constants.js";
+import { readSession } from "./control-plane-auth.js";
+import { createCodeUsageReporter } from "./code-usage.js";
 
 function executableOnPath(name, env = process.env) {
   return String(env.PATH || "").split(path.delimiter).map(dir => path.join(dir, name)).find(fs.existsSync);
@@ -24,12 +26,21 @@ function findInstalledRuntime(options = {}) {
   }
 }
 
+function findBundledRuntime(options = {}) {
+  const runtimePlatform = options.platform || process.platform;
+  const binaryName = runtimePlatform === "win32" ? "scifcode-runtime.exe" : "scifcode-runtime";
+  const candidate = path.join(path.dirname(options.execPath || process.execPath), binaryName);
+  return fs.existsSync(candidate) ? candidate : undefined;
+}
+
 export function resolveRuntime(options = {}) {
   const env = options.env || process.env;
   if (env.SCIFCODE_RUNTIME_BIN) {
     if (!fs.existsSync(env.SCIFCODE_RUNTIME_BIN)) throw new Error(`SCIFCODE_RUNTIME_BIN does not exist: ${env.SCIFCODE_RUNTIME_BIN}`);
     return { command: env.SCIFCODE_RUNTIME_BIN, argsPrefix: [], source: "binary" };
   }
+  const bundledBin = findBundledRuntime(options);
+  if (bundledBin) return { command: bundledBin, argsPrefix: [], source: "binary" };
   const installedBin = findInstalledRuntime(options);
   if (installedBin) return { command: installedBin, argsPrefix: [], source: "package" };
   const sourceDir = env.SCIFCODE_SOURCE_DIR || defaultSourceDir();
@@ -81,35 +92,62 @@ export function buildRuntimeArgs(userArgs = [], env = process.env, runtime = res
   return [...runtime.argsPrefix, "--model", model, ...withoutModelOverrides];
 }
 
-export function buildRuntimeEnv(env = process.env) {
+export function buildRuntimeEnv(env = process.env, options = {}) {
   const runtimeEnv = { ...env };
-  if (!runtimeEnv[API_KEY_ENV_NAME] && env[LEGACY_API_KEY_ENV_NAME]) runtimeEnv[API_KEY_ENV_NAME] = env[LEGACY_API_KEY_ENV_NAME];
+  if (!runtimeEnv[SESSION_TOKEN_ENV_NAME]) {
+    const session = (options.readSessionFn || readSession)({ homeDir: options.homeDir });
+    options.onSession?.(session);
+    const expiresAt = session?.expiresAt ? Date.parse(session.expiresAt) : Number.POSITIVE_INFINITY;
+    if (session?.sessionToken && expiresAt > Date.now()) {
+      runtimeEnv[SESSION_TOKEN_ENV_NAME] = session.sessionToken;
+    }
+  }
   return runtimeEnv;
 }
 
-export function validateLagunaApiKey(env = process.env) { return Boolean(env[API_KEY_ENV_NAME] || env[LEGACY_API_KEY_ENV_NAME]); }
-export function printMissingApiKey(stderr = console.error) {
-  stderr(`Scifcode requires ${API_KEY_ENV_NAME}.`);
+export function validateSession(env = process.env) { return Boolean(env[SESSION_TOKEN_ENV_NAME]); }
+export function printMissingSession(stderr = console.error) {
+  stderr("Scifcode requires a control-plane session.");
   stderr("");
-  stderr(`Run:\n  export ${API_KEY_ENV_NAME}="endpoint_or_modal_bearer_token"\n  scifcode`);
+  stderr("Run:\n  scifcode login");
 }
 
 export function runRuntime(userArgs = [], options = {}) {
   const env = options.env || process.env;
   const stderr = options.stderr || console.error;
   const exit = options.exit || process.exit;
-  if (!validateLagunaApiKey(env)) { printMissingApiKey(stderr); exit(1); return null; }
+  let storedSession;
+  const runtimeEnv = buildRuntimeEnv(env, {
+    ...options,
+    onSession: session => { storedSession = session; }
+  });
+  if (!validateSession(runtimeEnv)) { printMissingSession(stderr); exit(1); return null; }
   let runtime;
   try { runtime = (options.resolveRuntimeFn || resolveRuntime)({ env }); }
   catch (error) { stderr("Failed to resolve the Scifcode agent runtime."); stderr(error.message); exit(1); return null; }
-  const runtimeEnv = buildRuntimeEnv(env);
   const projectDir = options.cwd || process.cwd();
+  let codeUsageReporter;
+  try {
+    codeUsageReporter = (options.createCodeUsageReporterFn || createCodeUsageReporter)({
+      cwd: projectDir,
+      env: runtimeEnv,
+      sessionToken: runtimeEnv[SESSION_TOKEN_ENV_NAME],
+      controlPlaneUrl: storedSession?.controlPlaneUrl || getControlPlaneUrl(env),
+      fetchFn: options.fetchFn
+    });
+  } catch (error) {
+    stderr(`Could not start Git diff tracking: ${error.message}`);
+  }
   const child = (options.spawnFn || spawn)(runtime.command, buildRuntimeArgs(userArgs, runtimeEnv, runtime, projectDir), {
     stdio: "inherit",
     env: runtimeEnv,
     cwd: runtime.cwd || projectDir
   });
-  child.on("exit", code => exit(code ?? 0));
+  child.on("exit", code => {
+    Promise.resolve(codeUsageReporter?.report())
+      .catch(error => stderr(`Could not report code usage: ${error.message}`))
+      .finally(() => exit(code ?? 0));
+  });
   child.on("error", error => { stderr("Failed to launch Scifcode."); stderr(error.message); exit(1); });
   return child;
 }