@onkernel/cli 0.0.1-alpha.1

package/README.md

@@ -0,0 +1,15 @@
+# cli
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.2.9. [Bun](https://bun.sh) is a fast all-in-one JavaScript runtime.

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,759 @@
+import { Command } from 'commander';
+import fs2 from 'fs';
+import getPort from 'get-port';
+import os2 from 'os';
+import path3, { dirname } from 'path';
+import { parse, stringify } from 'smol-toml';
+import fsExtra from 'fs-extra';
+import Parser from 'tree-sitter';
+import Python from 'tree-sitter-python';
+import TypeScript from 'tree-sitter-typescript';
+import { z } from 'zod';
+import { execa } from 'execa';
+import { fileURLToPath } from 'url';
+
+// index.ts
+
+// lib/constants.ts
+var PYTHON_PACKAGE_NAME = "kernel";
+var NODE_PACKAGE_NAME = "@onkernel/sdk";
+async function runForExitCode(command, options = {}) {
+  try {
+    const cwd = options.cwd ? path3.resolve(options.cwd) : process.cwd();
+    const { exitCode } = await execa(command, {
+      shell: true,
+      cwd,
+      stdio: "ignore",
+      // Don't show any output
+      reject: false
+      // Don't throw on non-zero exit code
+    });
+    return exitCode ?? 1;
+  } catch (error) {
+    return 1;
+  }
+}
+async function runInDirectory(command, cwd) {
+  const resolvedCwd = path3.resolve(cwd);
+  await execa(command, {
+    shell: true,
+    cwd: resolvedCwd,
+    stdio: "inherit"
+  });
+}
+function getPackageVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const pkgJsonPath = path3.join(__dirname, "..", "package.json");
+  const content = fsExtra.readJSONSync(pkgJsonPath);
+  if (!content.version) {
+    throw new Error("package.json does not contain a version");
+  }
+  return content.version;
+}
+
+// lib/package.ts
+var KernelFunctionSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("schedule"),
+    name: z.string(),
+    cron: z.string(),
+    uses_browser: z.boolean().optional()
+  }),
+  z.object({
+    type: z.literal("http"),
+    name: z.string(),
+    path: z.string(),
+    method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]),
+    uses_browser: z.boolean().optional()
+  }),
+  z.object({
+    type: z.literal("function"),
+    name: z.string(),
+    uses_browser: z.boolean().optional()
+  })
+]);
+z.object({
+  entrypoint: z.string(),
+  functions: z.array(KernelFunctionSchema)
+});
+function findPythonDecoratedFunctions(filePath) {
+  const parser = new Parser();
+  parser.setLanguage(Python);
+  const code = fs2.readFileSync(filePath, "utf8");
+  const tree = parser.parse(code);
+  const rootNode = tree.rootNode;
+  const result = [];
+  const functionNodes = [];
+  traverseTree(rootNode, (node) => {
+    if (node.type === "function_definition") {
+      functionNodes.push(node);
+    }
+  });
+  for (const node of functionNodes) {
+    const nameNode = node.childForFieldName("name");
+    if (!nameNode) continue;
+    const functionName = nameNode.text;
+    let decoratorFound = false;
+    let curNode = node.previousSibling;
+    while (curNode && curNode.type === "decorator") {
+      const decoratorNameNode = curNode.child(1);
+      if (decoratorNameNode) {
+        const decoratorName = decoratorNameNode.text;
+        if (decoratorName === "func") {
+          decoratorFound = true;
+          result.push({
+            type: "function",
+            name: functionName,
+            uses_browser: code.includes("use_browser") && code.includes(`def ${functionName}`)
+          });
+          break;
+        }
+      }
+      curNode = curNode.previousSibling;
+    }
+    if (!decoratorFound) {
+      const funcStartLine = node.startPosition.row;
+      const codeLines = code.split("\n");
+      for (let i = Math.max(0, funcStartLine - 3); i < funcStartLine; i++) {
+        const line = codeLines[i]?.trim() || "";
+        if (line.startsWith("@func")) {
+          result.push({
+            type: "function",
+            name: functionName,
+            uses_browser: code.includes("use_browser") && code.includes(`def ${functionName}`)
+          });
+          break;
+        }
+      }
+    }
+  }
+  return result;
+}
+function traverseTree(node, callback) {
+  callback(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      traverseTree(child, callback);
+    }
+  }
+}
+function findTypeScriptDecoratedFunctions(filePath) {
+  const parser = new Parser();
+  parser.setLanguage(TypeScript.typescript);
+  const code = fs2.readFileSync(filePath, "utf8");
+  const tree = parser.parse(code);
+  const rootNode = tree.rootNode;
+  traverseTreeForDebug(rootNode);
+  const results = walkTreeForKernelExports(rootNode, code);
+  if (results.length === 0 && code.includes("export default Kernel.func")) {
+    results.push({
+      type: "function",
+      name: "default",
+      uses_browser: code.includes("useBrowser")
+    });
+  } else if (results.length === 0 && code.includes("export default Kernel.schedule")) {
+    results.push({
+      type: "schedule",
+      name: "default",
+      cron: "* * * * *",
+      // Default
+      uses_browser: code.includes("useBrowser")
+    });
+  } else if (results.length === 0 && code.includes("export default Kernel.endpoint")) {
+    results.push({
+      type: "http",
+      name: "default",
+      path: "/",
+      method: "GET",
+      uses_browser: code.includes("useBrowser")
+    });
+  }
+  return results;
+}
+function traverseTreeForDebug(node, level) {
+  for (let i = 0; i < node.namedChildCount; i++) {
+    const child = node.namedChild(i);
+    traverseTreeForDebug(child);
+  }
+}
+function walkTreeForKernelExports(rootNode, code) {
+  const results = [];
+  for (let i = 0; i < rootNode.namedChildCount; i++) {
+    const node = rootNode.namedChild(i);
+    if (!node) continue;
+    if (node.type === "export_statement") {
+      if (node.text.startsWith("export default")) {
+        const declaration = node.childForFieldName("declaration");
+        if (!declaration) {
+          continue;
+        }
+        if (declaration.type === "call_expression") {
+          const callExpr = declaration;
+          if (callExpr.childCount > 0 && callExpr.child(0)?.type === "member_expression") {
+            const memberExpr = callExpr.child(0);
+            const object = memberExpr.childForFieldName("object");
+            const property = memberExpr.childForFieldName("property");
+            if (object?.text === "Kernel") {
+              const method = property?.text;
+              const usesBrowser = code.includes("useBrowser");
+              if (method === "func") {
+                results.push({
+                  type: "function",
+                  name: "default",
+                  uses_browser: usesBrowser
+                });
+              } else if (method === "schedule") {
+                results.push({
+                  type: "schedule",
+                  name: "default",
+                  cron: "* * * * *",
+                  // Default
+                  uses_browser: usesBrowser
+                });
+              } else if (method === "endpoint") {
+                results.push({
+                  type: "http",
+                  name: "default",
+                  path: "/",
+                  method: "GET",
+                  uses_browser: usesBrowser
+                });
+              }
+            }
+          }
+        }
+      }
+    } else if (node.type === "lexical_declaration") {
+      const decl = node.childForFieldName("declaration");
+      if (!decl) continue;
+      for (let j = 0; j < decl.namedChildCount; j++) {
+        const varDecl = decl.namedChild(j);
+        if (!varDecl) continue;
+        const varNameNode = varDecl.childForFieldName("name");
+        const valueNode = varDecl.childForFieldName("value");
+        if (!varNameNode || !valueNode) continue;
+        if (valueNode.type === "call_expression" && valueNode.child(0)?.type === "member_expression") {
+          const memberExpr = valueNode.child(0);
+          const object = memberExpr.childForFieldName("object");
+          const property = memberExpr.childForFieldName("property");
+          if (object?.text === "Kernel") {
+            const method = property?.text;
+            const name = varNameNode.text;
+            const usesBrowser = code.includes("useBrowser");
+            if (method === "func") {
+              results.push({
+                type: "function",
+                name,
+                uses_browser: usesBrowser
+              });
+            } else if (method === "schedule") {
+              let cronExpression = "* * * * *";
+              results.push({
+                type: "schedule",
+                name,
+                cron: cronExpression,
+                uses_browser: usesBrowser
+              });
+            } else if (method === "endpoint") {
+              let path5 = "/";
+              let method2 = "GET";
+              results.push({
+                type: "http",
+                name,
+                path: path5,
+                method: method2,
+                uses_browser: usesBrowser
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+async function packageApp(config) {
+  const { sourceDir, entrypoint, targetDir } = config;
+  if (fs2.existsSync(targetDir)) {
+    fs2.rmSync(targetDir, { recursive: true, force: true });
+  }
+  fs2.mkdirSync(targetDir, { recursive: true });
+  const entrypointRelative = path3.relative(sourceDir, entrypoint);
+  const extension = path3.extname(entrypoint);
+  let functions = [];
+  if (extension === ".py") {
+    functions = findPythonDecoratedFunctions(entrypoint);
+  } else if (extension === ".ts") {
+    functions = findTypeScriptDecoratedFunctions(entrypoint);
+  } else {
+    throw new Error(`Unsupported file extension: ${extension}`);
+  }
+  const kernelJson = {
+    entrypoint: entrypointRelative,
+    functions
+  };
+  const kernelJsonPath = path3.join(targetDir, "kernel.json");
+  fs2.writeFileSync(kernelJsonPath, JSON.stringify(kernelJson, null, 2));
+  copyDirectoryContents(sourceDir, targetDir);
+  if (extension === ".ts") {
+    if (config.tsOptions?.kernelDependencyOverride) {
+      const packageJsonPath = path3.join(targetDir, "package.json");
+      const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+      packageJson.dependencies[NODE_PACKAGE_NAME] = config.tsOptions.kernelDependencyOverride;
+      fs2.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    await runInDirectory(`pnpm i`, targetDir);
+  }
+  return kernelJsonPath;
+}
+function copyDirectoryContents(sourceDir, targetDir) {
+  fsExtra.copySync(sourceDir, targetDir, {
+    filter: (src) => {
+      const basename = path3.basename(src);
+      return ![".build", "node_modules", ".git", ".mypy_cache", ".venv", "__pycache__"].includes(
+        basename
+      );
+    },
+    overwrite: true
+  });
+}
+
+// lib/invoke.ts
+var INVOKE_BASE_DIR = path3.join(
+  os2.homedir(),
+  ".local",
+  "state",
+  "kernel",
+  "local",
+  "invoke"
+);
+function overwriteKernelDendencyInPyproject(pyprojectPath, kernelDependencyOverride) {
+  const pyproject = parse(fs2.readFileSync(pyprojectPath, "utf8"));
+  if (!pyproject.project) {
+    pyproject.project = { dependencies: [] };
+  } else if (!pyproject.project.dependencies) {
+    pyproject.project.dependencies = [];
+  }
+  pyproject.project.dependencies = pyproject.project.dependencies.filter((dep) => {
+    return !dep.startsWith(PYTHON_PACKAGE_NAME);
+  });
+  if (!kernelDependencyOverride.startsWith("/") && !kernelDependencyOverride.startsWith("./") && !kernelDependencyOverride.startsWith("../")) {
+    pyproject.project.dependencies.push(kernelDependencyOverride);
+  } else {
+    pyproject.project.dependencies.push(PYTHON_PACKAGE_NAME);
+    if (!pyproject.tool) {
+      pyproject.tool = {};
+    }
+    if (!pyproject.tool.uv) {
+      pyproject.tool.uv = {};
+    }
+    if (!pyproject.tool.uv.sources) {
+      pyproject.tool.uv.sources = {};
+    }
+    pyproject.tool.uv.sources.kernel = { path: kernelDependencyOverride };
+  }
+  fs2.writeFileSync(pyprojectPath, stringify(pyproject));
+}
+function overwriteKernelDendencyInRequirementsTxt(requirementsTxtPath, kernelDependencyOverride) {
+  const requirementsTxt = fs2.readFileSync(requirementsTxtPath, "utf8");
+  const requirementsTxtLines = requirementsTxt.split("\n");
+  const newRequirementsTxtLines = requirementsTxtLines.filter((line) => {
+    return !line.startsWith(PYTHON_PACKAGE_NAME);
+  });
+  if (!kernelDependencyOverride.startsWith("/") && !kernelDependencyOverride.startsWith("./") && !kernelDependencyOverride.startsWith("../")) {
+    newRequirementsTxtLines.push(`${PYTHON_PACKAGE_NAME} @ file:${kernelDependencyOverride}`);
+  } else {
+    newRequirementsTxtLines.push(kernelDependencyOverride);
+  }
+  fs2.writeFileSync(requirementsTxtPath, newRequirementsTxtLines.join("\n"));
+}
+async function preparePythonInvokeEnvironment(options) {
+  const { appName, appDir, bootLoaderDir} = options;
+  const invokeDir = path3.join(INVOKE_BASE_DIR, appName);
+  if (fs2.existsSync(invokeDir)) {
+    fs2.rmSync(invokeDir, { recursive: true, force: true });
+  }
+  fs2.mkdirSync(invokeDir, { recursive: true });
+  copyDirectoryContents(bootLoaderDir, invokeDir);
+  if (options.kernelDependencyOverride) {
+    if (fs2.existsSync(path3.join(invokeDir, "pyproject.toml"))) {
+      overwriteKernelDendencyInPyproject(
+        path3.join(invokeDir, "pyproject.toml"),
+        options.kernelDependencyOverride
+      );
+    }
+    if (fs2.existsSync(path3.join(appDir, "pyproject.toml"))) {
+      overwriteKernelDendencyInPyproject(
+        path3.join(appDir, "pyproject.toml"),
+        options.kernelDependencyOverride
+      );
+    }
+    if (fs2.existsSync(path3.join(appDir, "requirements.txt"))) {
+      overwriteKernelDendencyInRequirementsTxt(
+        path3.join(appDir, "requirements.txt"),
+        options.kernelDependencyOverride
+      );
+    }
+  }
+  if (!fs2.existsSync(path3.join(appDir, "requirements.txt"))) {
+    await runInDirectory(
+      `/bin/bash -c 'uv venv && source .venv/bin/activate &&       uv sync --no-cache &&       uv pip freeze > requirements.txt'`,
+      appDir
+    );
+  }
+  await runInDirectory(
+    `/bin/bash -c 'uv venv && source .venv/bin/activate &&     uv add -r ${path3.join(appDir, "requirements.txt")}'`,
+    invokeDir
+  );
+  return invokeDir;
+}
+async function prepareTypeScriptInvokeEnvironment(options) {
+  const { appName, appDir, bootLoaderDir } = options;
+  const invokeDir = path3.join(INVOKE_BASE_DIR, appName);
+  if (fs2.existsSync(invokeDir)) {
+    fs2.rmSync(invokeDir, { recursive: true, force: true });
+  }
+  fs2.mkdirSync(invokeDir, { recursive: true });
+  copyDirectoryContents(bootLoaderDir, invokeDir);
+  if (options.kernelDependencyOverride) {
+    const packageJsonPath = path3.join(invokeDir, "package.json");
+    const packageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    packageJson.dependencies[NODE_PACKAGE_NAME] = options.kernelDependencyOverride;
+    fs2.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+  const appPackageJsonPath = path3.join(appDir, "package.json");
+  const invokePackageJsonPath = path3.join(invokeDir, "package.json");
+  if (fs2.existsSync(appPackageJsonPath) && fs2.existsSync(invokePackageJsonPath)) {
+    const appPackageJson = JSON.parse(fs2.readFileSync(appPackageJsonPath, "utf8"));
+    const invokePackageJson = JSON.parse(fs2.readFileSync(invokePackageJsonPath, "utf8"));
+    if (appPackageJson.dependencies) {
+      if (!invokePackageJson.dependencies) {
+        invokePackageJson.dependencies = {};
+      }
+      for (const [depName, depVersion] of Object.entries(appPackageJson.dependencies)) {
+        if (!invokePackageJson.dependencies[depName]) {
+          invokePackageJson.dependencies[depName] = depVersion;
+        }
+      }
+    }
+    if (appPackageJson.devDependencies) {
+      if (!invokePackageJson.devDependencies) {
+        invokePackageJson.devDependencies = {};
+      }
+      for (const [depName, depVersion] of Object.entries(appPackageJson.devDependencies)) {
+        if (!invokePackageJson.devDependencies[depName]) {
+          invokePackageJson.devDependencies[depName] = depVersion;
+        }
+      }
+    }
+    fs2.writeFileSync(invokePackageJsonPath, JSON.stringify(invokePackageJson, null, 2));
+    console.log("Merged dependencies in package.json");
+    await runInDirectory("pnpm i", invokeDir);
+  }
+  return invokeDir;
+}
+
+// index.ts
+var program = new Command();
+var LOCAL_APPS_BASE_DIR = path3.join(os2.homedir(), ".local", "state", "kernel", "local", "apps");
+var BOOT_PY_PATH = process.env.KERNEL_BOOT_PY_PATH || path3.join(os2.homedir(), "code", "onkernel", "kernel", "packages", "boot-py");
+var BOOT_TS_PATH = process.env.KERNEL_BOOT_TS_PATH || path3.join(os2.homedir(), "code", "onkernel", "kernel", "packages", "boot-ts");
+var KERNEL_TS_SDK_OVERRIDE = process.env.KERNEL_TS_SDK_OVERRIDE || void 0;
+var KERNEL_PYTHON_SDK_OVERRIDE = process.env.KERNEL_PYTHON_SDK_OVERRIDE || void 0;
+program.name("kernel").description("CLI for Kernel deployment and invocation").version(getPackageVersion());
+program.command("deploy").description("Deploy a Kernel application").argument("<entrypoint>", "Path to entrypoint file (TypeScript or Python)").option(
+  "--local",
+  "Does not publish the app to Kernel, but installs it on disk for invoking locally"
+).option("--name <name>", "Name for the deployed application").action(async (entrypoint, options) => {
+  if (!options.name) {
+    console.error("Error: --name option is required");
+    process.exit(1);
+  }
+  const resolvedEntrypoint = path3.resolve(entrypoint);
+  if (!fs2.existsSync(resolvedEntrypoint)) {
+    console.error(`Error: Entrypoint ${resolvedEntrypoint} doesn't exist`);
+    process.exit(1);
+  }
+  const sourceDir = path3.dirname(resolvedEntrypoint);
+  const localAppsDir = path3.join(LOCAL_APPS_BASE_DIR, options.name);
+  await packageApp({
+    sourceDir,
+    entrypoint: resolvedEntrypoint,
+    targetDir: localAppsDir,
+    tsOptions: {
+      kernelDependencyOverride: KERNEL_TS_SDK_OVERRIDE
+    }
+  });
+  if (options.local) {
+    console.log(`App "${options.name}" successfully installed to ${localAppsDir}`);
+  } else {
+    console.log(`Deploying ${resolvedEntrypoint} as "${options.name}"...`);
+    console.error("TODO: implement cloud :-p");
+    process.exit(1);
+  }
+});
+program.command("invoke").description("Invoke a deployed Kernel application").option("--local", "Invoke a locally deployed application").option("--name <name>", "Name of the application to invoke").option("--with-browser", "Provision browser infrastructure for the script").option("--func <name>", "Name of the function to invoke (default: the first function found)").argument("[payload]", "JSON payload to send to the application", "{}").action(async (payload, options) => {
+  if (!options.name) {
+    console.error("Error: --name option is required");
+    process.exit(1);
+  }
+  let parsedPayload;
+  try {
+    parsedPayload = JSON.parse(payload);
+  } catch (error) {
+    console.error("Error: Invalid JSON payload");
+    process.exit(1);
+  }
+  if (!options.local) {
+    console.log(`Invoking "${options.name}" in the cloud is not implemented yet`);
+    process.exit(1);
+  }
+  console.log(
+    `Invoking "${options.name}" with${options.withBrowser ? " browser and" : ""} payload:`
+  );
+  console.log(JSON.stringify(parsedPayload, null, 2));
+  const localAppsDir = path3.join(LOCAL_APPS_BASE_DIR, options.name);
+  if (!fs2.existsSync(localAppsDir)) {
+    console.error(`Error: App "${options.name}" not found in ${localAppsDir}`);
+    console.error("Did you deploy it with --local first?");
+    process.exit(1);
+  }
+  const kernelJsonPath = path3.join(localAppsDir, "kernel.json");
+  if (!fs2.existsSync(kernelJsonPath)) {
+    console.error(`Error: kernel.json not found in ${localAppsDir}`);
+    process.exit(1);
+  }
+  const kernelJson = JSON.parse(fs2.readFileSync(kernelJsonPath, "utf8"));
+  const entrypointExt = path3.extname(kernelJson.entrypoint);
+  const isPythonApp = entrypointExt.toLowerCase() === ".py";
+  const isTypeScriptApp = entrypointExt.toLowerCase() === ".ts";
+  try {
+    if (isPythonApp) {
+      await invokePythonApp(localAppsDir, kernelJson, parsedPayload, options);
+    } else if (isTypeScriptApp) {
+      await invokeTypeScriptApp(localAppsDir, kernelJson, parsedPayload, options);
+    } else {
+      throw new Error(`Unsupported app type: ${entrypointExt}`);
+    }
+  } catch (error) {
+    console.error("Error invoking application:", error);
+    process.exit(1);
+  }
+});
+async function waitForStartupMessage(childProcess, timeoutMs = 3e4) {
+  return new Promise(async (resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error("Timeout waiting for application startup."));
+    }, timeoutMs);
+    const reader = childProcess.stderr.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const text = decoder.decode(value);
+        process.stderr.write(text);
+        if (text.includes("Application startup complete.") || text.includes("Kernel application running")) {
+          clearTimeout(timeout);
+          resolve();
+          break;
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+}
+async function getBootPyPath() {
+  const bootPyDir = BOOT_PY_PATH;
+  if (!fs2.existsSync(bootPyDir)) {
+    console.error(`Error: Python boot loader not found at ${bootPyDir}`);
+    console.error("Please ensure the boot-py package is installed");
+    process.exit(1);
+  }
+  return bootPyDir;
+}
+async function getBootTsPath() {
+  const bootTsDir = BOOT_TS_PATH;
+  if (!fs2.existsSync(bootTsDir)) {
+    console.error(`Error: TypeScript boot loader not found at ${bootTsDir}`);
+    console.error("Please ensure the boot-ts package is installed");
+    process.exit(1);
+  }
+  return bootTsDir;
+}
+async function isUvInstalled() {
+  const exitCode = await runForExitCode("uv --version");
+  return exitCode === 0;
+}
+async function invokePythonApp(appDir, kernelJson, payload, options) {
+  const uvInstalled = await isUvInstalled();
+  if (!uvInstalled) {
+    console.error("Error: uv is not installed. Please install it with:");
+    console.error("  curl -LsSf https://astral.sh/uv/install.sh | sh");
+    process.exit(1);
+  }
+  const bootPyDir = await getBootPyPath();
+  const invokeDir = await preparePythonInvokeEnvironment({
+    appName: options.name,
+    appDir,
+    bootLoaderDir: bootPyDir,
+    kernelDependencyOverride: KERNEL_PYTHON_SDK_OVERRIDE
+  });
+  const port = await getPort();
+  console.log(`Starting Python boot server for ${appDir} on port ${port}...`);
+  const pythonProcess = Bun.spawn(
+    ["uv", "run", "--no-cache", "python", "main.py", appDir, "--port", port.toString()],
+    {
+      cwd: invokeDir,
+      stdio: ["inherit", "inherit", "pipe"],
+      env: {
+        ...process.env,
+        // Pass through any browser-related environment variables
+        ...options.withBrowser ? { KERNEL_WITH_BROWSER: "true" } : {}
+      }
+    }
+  );
+  console.log(`Waiting for Python application to start...`);
+  try {
+    await waitForStartupMessage(pythonProcess);
+  } catch (error) {
+    console.error("Error while waiting for application to start:", error);
+    process.exit(1);
+  }
+  let serverReached = false;
+  try {
+    try {
+      const healthCheck = await fetch(`http://localhost:${port}/`, {
+        method: "GET"
+      }).catch(() => null);
+      if (!healthCheck) {
+        throw new Error(`Could not connect to boot server at http://localhost:${port}/`);
+      }
+      serverReached = true;
+    } catch (error) {
+      console.error("Error connecting to boot server:", error);
+      console.error("The boot server might not have started correctly.");
+      process.exit(1);
+    }
+    let funcName = options.func;
+    if (!funcName) {
+      const firstFunction = kernelJson.functions.find((f) => f.type === "function");
+      if (firstFunction) {
+        funcName = firstFunction.name;
+      } else {
+        throw new Error("No functions found in the application");
+      }
+    }
+    console.log(`Invoking function "${funcName}"...`);
+    const response = await fetch(`http://localhost:${port}/function/${funcName}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    }).catch((error) => {
+      console.error(`Failed to connect to function endpoint: ${error.message}`);
+      throw new Error(
+        `Could not connect to function endpoint at http://localhost:${port}/function/${funcName}`
+      );
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`HTTP error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    console.log("Result:", JSON.stringify(result, null, 2));
+    return result;
+  } finally {
+    if (serverReached) {
+      console.log("Shutting down boot server...");
+    }
+    pythonProcess.kill();
+  }
+}
+async function invokeTypeScriptApp(appDir, kernelJson, payload, options) {
+  const bootTsDir = await getBootTsPath();
+  const invokeDir = await prepareTypeScriptInvokeEnvironment({
+    appName: options.name,
+    appDir,
+    bootLoaderDir: bootTsDir,
+    kernelDependencyOverride: KERNEL_TS_SDK_OVERRIDE
+  });
+  const port = await getPort();
+  console.log(`Starting TypeScript boot server for ${appDir} on port ${port}...`);
+  const tsProcess = Bun.spawn(["./node_modules/.bin/tsx", "index.ts", appDir, port.toString()], {
+    cwd: invokeDir,
+    stdio: ["inherit", "inherit", "pipe"],
+    env: {
+      ...process.env,
+      // Pass through any browser-related environment variables
+      ...options.withBrowser ? { KERNEL_WITH_BROWSER: "true" } : {}
+    }
+  });
+  tsProcess.exited.then((exitCode) => {
+    if (exitCode !== 0) {
+      console.error(`Boot server exited with code ${exitCode}`);
+    }
+  });
+  console.log(`Waiting for TypeScript application to start...`);
+  try {
+    await waitForStartupMessage(tsProcess);
+  } catch (error) {
+    console.error("Error while waiting for application to start:", error);
+    process.exit(1);
+  }
+  let serverReached = false;
+  try {
+    try {
+      const healthCheck = await fetch(`http://localhost:${port}/`, {
+        method: "GET"
+      }).catch(() => null);
+      if (!healthCheck) {
+        throw new Error(`Could not connect to boot server at http://localhost:${port}/`);
+      }
+      serverReached = true;
+    } catch (error) {
+      console.error("Error connecting to boot server:", error);
+      console.error("The boot server might not have started correctly.");
+      process.exit(1);
+    }
+    let funcName = options.func;
+    if (!funcName) {
+      const firstFunction = kernelJson.functions.find((f) => f.type === "function");
+      if (firstFunction) {
+        funcName = firstFunction.name;
+      } else {
+        throw new Error("No functions found in the application");
+      }
+    }
+    console.log(`Invoking function "${funcName}"...`);
+    const response = await fetch(`http://localhost:${port}/function/${funcName}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    }).catch((error) => {
+      console.error(`Failed to connect to function endpoint: ${error.message}`);
+      throw new Error(
+        `Could not connect to function endpoint at http://localhost:${port}/function/${funcName}`
+      );
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`HTTP error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    console.log("Result:", JSON.stringify(result, null, 2));
+    return result;
+  } finally {
+    if (serverReached) {
+      console.log("Shutting down boot server...");
+    }
+    tsProcess.kill();
+  }
+}
+program.parse();

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@onkernel/cli",
+  "version": "0.0.1-alpha.1",
+  "description": "Kernel CLI",
+  "type": "module",
+  "module": "index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "kernel": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup --config tsup.config.js"
+  },
+  "keywords": [
+    "kernel",
+    "cli",
+    "ai",
+    "llm",
+    "llms",
+    "agent",
+    "agents",
+    "dev",
+    "development",
+    "deploy",
+    "deployment",
+    "build",
+    "workflow",
+    "typescript",
+    "command-line",
+    "devtools"
+  ],
+  "author": "",
+  "dependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "commander": "^13.1.0",
+    "execa": "^9.5.2",
+    "fs-extra": "^11.3.0",
+    "get-port": "^7.1.0",
+    "smol-toml": "^1.3.4",
+    "tree-sitter": "^0.22.4",
+    "tree-sitter-python": "^0.23.6",
+    "tree-sitter-typescript": "^0.23.2",
+    "type-fest": "^4.40.1",
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "tsup": "^8.4.0"
+  }
+}