@onkernel/cli 0.0.1-alpha.1 → 0.0.2

package/dist/index.d.ts

@@ -1,2 +1 @@
-
-export {  }
+#!/usr/bin/env bun

package/dist/index.js

@@ -1,504 +1,122 @@
+#!/usr/bin/env bun
+import { Kernel } from '@onkernel/sdk';
+import chalk from 'chalk';
 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 fs, { createReadStream } from 'fs';
+import path2 from 'path';
+import * as tmp from 'tmp';
+import archiver from 'archiver';
 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';
+import walk from 'ignore-walk';
 
-// 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 pkgJsonPath = path2.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
+async function zipDirectory(inputDir, outputZip) {
+  const entries = await walk({
+    path: inputDir,
+    ignoreFiles: [".gitignore", ".dockerignore"],
+    includeEmpty: true,
+    follow: false
   });
-}
-
-// 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);
+  const output = fs.createWriteStream(outputZip);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  const finalizePromise = new Promise((resolve, reject) => {
+    output.on("close", resolve);
+    archive.on("error", reject);
   });
-  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
-      );
+  archive.pipe(output);
+  for (const entry of entries) {
+    const fullPath = path2.join(inputDir, entry);
+    const stat = fs.statSync(fullPath);
+    const archivePath = entry.split(path2.sep).join("/");
+    if (stat.isFile()) {
+      archive.file(fullPath, { name: archivePath });
+    } else if (stat.isDirectory()) {
+      archive.append("", { name: archivePath.endsWith("/") ? archivePath : archivePath + "/" });
     }
   }
-  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;
+  await archive.finalize();
+  await finalizePromise;
 }
 
 // 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);
+if (process.argv.length === 3 && ["-v", "--version"].includes(process.argv[2])) {
+  console.log(getPackageVersion());
+  process.exit(0);
+}
+program.name("kernel").description("CLI for Kernel deployment and invocation");
+program.command("deploy").description("Deploy a Kernel application").argument("<entrypoint>", "Path to entrypoint file (TypeScript or Python)").option("--version <version>", "Specify a version for the app (default: latest)").option("--force", "Allow overwrite of an existing version with the same name").action(async (entrypoint, options) => {
+  let { version: versionArg, force } = options;
+  if (!versionArg) {
+    versionArg = "latest";
+    if (force && force !== "true") {
+      console.error("Error: --force must be used when version is latest");
+      process.exit(1);
+    } else if (!force) {
+      force = "true";
+    }
   }
-  const resolvedEntrypoint = path3.resolve(entrypoint);
-  if (!fs2.existsSync(resolvedEntrypoint)) {
+  const resolvedEntrypoint = path2.resolve(entrypoint);
+  if (!fs.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
+  const sourceDir = path2.dirname(resolvedEntrypoint);
+  if (!process.env["KERNEL_API_KEY"]) {
+    console.error("Error: KERNEL_API_KEY environment variable is not set");
+    console.error("Please set your Kernel API key using: export KERNEL_API_KEY=your_api_key");
+    process.exit(1);
+  }
+  const client = new Kernel();
+  console.log(chalk.green(`Compressing files...`));
+  const tmpZipFile = tmp.fileSync({ postfix: ".zip" });
+  try {
+    await zipDirectory(path2.join(sourceDir), tmpZipFile.name);
+    console.log(chalk.green(`Deploying app (version: ${versionArg})...`));
+    const response = await client.apps.deploy(
+      {
+        file: createReadStream(tmpZipFile.name),
+        version: versionArg,
+        force,
+        entrypointRelPath: path2.relative(sourceDir, resolvedEntrypoint)
+      },
+      { maxRetries: 0 }
+    );
+    if (!response.success) {
+      console.error("Error deploying to Kernel:", response.message);
+      process.exit(1);
     }
-  });
-  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");
+    for (const app of response.apps) {
+      console.log(
+        chalk.green(
+          `App "${app.name}" successfully deployed to Kernel with action${app.actions.length > 1 ? "s" : ""}: ${app.actions.map((a) => a.name).join(", ")}`
+        )
+      );
+      console.log(
+        `You can invoke it with: kernel invoke${versionArg !== "latest" ? ` --version ${versionArg}` : ""} ${quoteIfNeeded(app.name)} ${quoteIfNeeded(app.actions[0].name)} '{ ... JSON payload ... }'`
+      );
+    }
+  } catch (error) {
+    console.error("Error deploying to Kernel:", error);
     process.exit(1);
+  } finally {
+    tmpZipFile.removeCallback();
   }
 });
-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);
+function quoteIfNeeded(str) {
+  if (str.includes(" ")) {
+    return `"${str}"`;
   }
+  return str;
+}
+program.command("invoke").description("Invoke a deployed Kernel application").option("--version <version>", "Specify a version of the app to invoke").argument("<app_name>", "Name of the application to invoke").argument("<action_name>", "Name of the action to invoke").argument("<payload>", "JSON payload to send to the application").action(async (appName, actionName, payload, options) => {
   let parsedPayload;
   try {
     parsedPayload = JSON.parse(payload);
@@ -506,254 +124,27 @@ program.command("invoke").description("Invoke a deployed Kernel application").op
     console.error("Error: Invalid JSON payload");
     process.exit(1);
   }
-  if (!options.local) {
-    console.log(`Invoking "${options.name}" in the cloud is not implemented yet`);
+  if (!process.env["KERNEL_API_KEY"]) {
+    console.error("Error: KERNEL_API_KEY environment variable is not set");
+    console.error("Please set your Kernel API key using: export KERNEL_API_KEY=your_api_key");
     process.exit(1);
   }
-  console.log(
-    `Invoking "${options.name}" with${options.withBrowser ? " browser and" : ""} payload:`
-  );
+  const client = new Kernel();
+  console.log(`Invoking "${appName}" with action "${actionName}" 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}`);
-    }
+    const response = await client.apps.invoke({
+      appName,
+      actionName,
+      payload,
+      ...options.version && { version: options.version }
+    });
+    console.log("Result:");
+    console.log(JSON.stringify(JSON.parse(response.output || "{}"), null, 2));
   } catch (error) {
     console.error("Error invoking application:", error);
     process.exit(1);
   }
+  return;
 });
-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

@@ -1,6 +1,6 @@
 {
   "name": "@onkernel/cli",
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.2",
   "description": "Kernel CLI",
   "type": "module",
   "module": "index.ts",
@@ -35,20 +35,20 @@
   ],
   "author": "",
   "dependencies": {
-    "@types/fs-extra": "^11.0.4",
+    "@onkernel/sdk": "0.1.0-alpha.9",
+    "@types/archiver": "^6.0.3",
+    "@types/ignore-walk": "^4.0.3",
+    "archiver": "^7.0.1",
+    "chalk": "^5.4.1",
     "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"
+    "ignore-walk": "^7.0.0",
+    "tmp": "^0.2.3",
+    "type-fest": "^4.40.1"
   },
   "devDependencies": {
-    "@types/bun": "latest",
+    "@types/fs-extra": "^11.0.4",
+    "@types/tmp": "^0.2.6",
     "tsup": "^8.4.0"
   }
 }