@jango-blockchained/hoox-cli 0.5.1 → 0.5.2

package/src/commands/init/init-command.ts

@@ -18,7 +18,11 @@ import {
 } from "@jango-blockchained/hoox-shared";
 import type { WorkersJsonConfig } from "@jango-blockchained/hoox-shared";
 import { CloudflareService } from "../../services/cloudflare/index.js";
-import { formatSuccess, formatError } from "../../utils/formatters.js";
+import {
+  getFormatOptions,
+  formatSuccess,
+  formatError,
+} from "../../utils/formatters.js";
 import { CLIError, ExitCode } from "../../utils/errors.js";
 import { theme } from "../../utils/theme.js";
 import { CLIProvisioner } from "./cli-provisioner.js";
@@ -204,7 +208,7 @@ EXAMPLES:
     .option("--resume", "Resume from saved wizard state")
     .option("--accept-risk", "Skip the risk acknowledgment confirmation")
     .action(async (options: InitOptions) => {
-      const globalOpts = program.opts() as { json?: boolean; quiet?: boolean };
+      const globalOpts = getFormatOptions(program);
       const isNonInteractive = Boolean(options.token && options.account);
 
       try {
@@ -213,7 +217,7 @@ EXAMPLES:
         const message = err instanceof Error ? err.message : String(err);
         p.log.error(message);
         formatError(new CLIError(message, ExitCode.ERROR), globalOpts);
-        process.exit(ExitCode.ERROR);
+        process.exitCode = ExitCode.ERROR;
       }
     });
 }
@@ -244,7 +248,7 @@ export async function runInitCommand(
     const error = await validateApiToken(cf, token);
     if (error) {
       formatError(new CLIError(error, ExitCode.ERROR), globalOpts);
-      process.exit(ExitCode.ERROR);
+      process.exitCode = ExitCode.ERROR;
     }
     if (!globalOpts.quiet) {
       formatSuccess("Cloudflare API token validated", globalOpts);
@@ -296,7 +300,7 @@ export async function runInitCommand(
       });
       if (p.isCancel(resumed)) {
         p.cancel("Setup cancelled.");
-        process.exit(0);
+        process.exitCode = 0;
       }
       if (!resumed) {
         engine = null;
@@ -320,12 +324,12 @@ export async function runInitCommand(
 
     if (p.isCancel(accepted)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     if (!accepted) {
       p.outro("Setup cancelled. See DISCLAIMER.md for full terms.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     // Step 0: Prerequisites check (always passes — CLI is running)
@@ -350,7 +354,7 @@ export async function runInitCommand(
 
       if (p.isCancel(apiToken)) {
         p.cancel("Setup cancelled.");
-        process.exit(0);
+        process.exitCode = 0;
       }
 
       p.log.step("Validating Cloudflare API token...");
@@ -379,7 +383,7 @@ export async function runInitCommand(
     });
     if (p.isCancel(accountResult)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     const secretStoreResult = await p.text({
@@ -389,7 +393,7 @@ export async function runInitCommand(
     });
     if (p.isCancel(secretStoreResult)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     const prefixResult = await p.text({
@@ -403,7 +407,7 @@ export async function runInitCommand(
     });
     if (p.isCancel(prefixResult)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     engine.execute({
@@ -440,7 +444,7 @@ export async function runInitCommand(
 
     if (p.isCancel(presetChoice)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     engine.execute({ preset: presetChoice as string });
@@ -471,7 +475,7 @@ export async function runInitCommand(
 
       if (p.isCancel(shouldProvision)) {
         p.cancel("Setup cancelled.");
-        process.exit(0);
+        process.exitCode = 0;
       }
 
       if (shouldProvision) {
@@ -529,7 +533,7 @@ export async function runInitCommand(
         const collected = await p.group(groupFields, {
           onCancel: () => {
             p.cancel("Setup cancelled.");
-            process.exit(0);
+            process.exitCode = 0;
           },
         });
 
@@ -569,7 +573,7 @@ export async function runInitCommand(
 
     if (p.isCancel(shouldDeploy)) {
       p.cancel("Setup cancelled.");
-      process.exit(0);
+      process.exitCode = 0;
     }
 
     if (shouldDeploy) {

package/src/commands/logs/logs-command.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Unit tests for the logs command.
  *

package/src/commands/monitor/monitor-command.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Unit tests for the monitor command.
  *
@@ -35,16 +34,19 @@ beforeEach(() => {
   process.exitCode = 0;
 
   // Restore originals
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    origCheckAll;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
+  (
+    MonitorService.prototype as unknown as Record<string, unknown>
+  ).checkAllWorkerHealth = origCheckAll;
+  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
     origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).query = origQuery;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).get = origGet;
-  (KvSyncService.prototype as Record<string, unknown>).set = origSet;
+  (DbService.prototype as unknown as Record<string, unknown>).query = origQuery;
+  (DbService.prototype as unknown as Record<string, unknown>).export =
+    origExport;
+  (
+    KvSyncService.prototype as unknown as Record<string, unknown>
+  ).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).get = origGet;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).set = origSet;
 
   // Fresh mocks
   checkAllWorkerHealthMock = mock(async () => ({
@@ -68,30 +70,36 @@ beforeEach(() => {
   setMock = mock(async (_nsId: string, _key: string, _value: string) => {});
 
   // Install mocks on prototypes
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    checkAllWorkerHealthMock;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
+  (
+    MonitorService.prototype as unknown as Record<string, unknown>
+  ).checkAllWorkerHealth = checkAllWorkerHealthMock;
+  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
     resolveDbNameMock;
-  (DbService.prototype as Record<string, unknown>).query = queryMock;
-  (DbService.prototype as Record<string, unknown>).export = exportMock;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    resolveNamespaceIdMock;
-  (KvSyncService.prototype as Record<string, unknown>).get = getMock;
-  (KvSyncService.prototype as Record<string, unknown>).set = setMock;
+  (DbService.prototype as unknown as Record<string, unknown>).query = queryMock;
+  (DbService.prototype as unknown as Record<string, unknown>).export =
+    exportMock;
+  (
+    KvSyncService.prototype as unknown as Record<string, unknown>
+  ).resolveNamespaceId = resolveNamespaceIdMock;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).get = getMock;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).set = setMock;
 });
 
 afterEach(() => {
   mock.restore();
-  (MonitorService.prototype as Record<string, unknown>).checkAllWorkerHealth =
-    origCheckAll;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
+  (
+    MonitorService.prototype as unknown as Record<string, unknown>
+  ).checkAllWorkerHealth = origCheckAll;
+  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
     origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).query = origQuery;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).get = origGet;
-  (KvSyncService.prototype as Record<string, unknown>).set = origSet;
+  (DbService.prototype as unknown as Record<string, unknown>).query = origQuery;
+  (DbService.prototype as unknown as Record<string, unknown>).export =
+    origExport;
+  (
+    KvSyncService.prototype as unknown as Record<string, unknown>
+  ).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).get = origGet;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).set = origSet;
 });
 
 async function importMonitorCommand(): Promise<{
@@ -185,7 +193,7 @@ describe("registerMonitorCommand", () => {
         throw new Error("Connection failed");
       });
       (
-        MonitorService.prototype as Record<string, unknown>
+        MonitorService.prototype as unknown as Record<string, unknown>
       ).checkAllWorkerHealth = checkAllWorkerHealthMock;
 
       const program = await createProgram();

package/src/commands/repair/repair-command.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Unit tests for the repair command.
  *
@@ -12,7 +11,6 @@ import { RepairService } from "./repair-service.js";
 import { CloudflareService } from "../../services/cloudflare/cloudflare-service.js";
 import { DbService } from "../../services/db/db-service.js";
 import { KvSyncService } from "../../services/kv/kv-sync-service.js";
-import { SecretsService } from "../../services/secrets/secrets-service.js";
 
 // Stubs
 let runSystemCheckMock: ReturnType<typeof mock>;
@@ -32,31 +30,39 @@ const origExport = DbService.prototype.export;
 const origReset = DbService.prototype.reset;
 const origResolveNs = KvSyncService.prototype.resolveNamespaceId;
 const origKvSet = KvSyncService.prototype.set;
-const origGetWorker = CloudflareService.prototype.deploy; // placeholder
-const origListWorkers = CloudflareService.prototype.deploy; // placeholder
 
 beforeEach(() => {
   mock.restore();
   process.exitCode = 0;
 
   // Restore originals
-  (RepairService.prototype as Record<string, unknown>).runSystemCheck =
-    origRunSystemCheck;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
-  (CloudflareService.prototype as Record<string, unknown>).d1List = origD1List;
-  (CloudflareService.prototype as Record<string, unknown>).kvList = origKvList;
-  (CloudflareService.prototype as Record<string, unknown>).r2List = origR2List;
-  (CloudflareService.prototype as Record<string, unknown>).queueList =
-    origQueueList;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
+  (
+    RepairService.prototype as unknown as Record<string, unknown>
+  ).runSystemCheck = origRunSystemCheck;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    origDeploy;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).d1List =
+    origD1List;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).kvList =
+    origKvList;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).r2List =
+    origR2List;
+  (
+    CloudflareService.prototype as unknown as Record<string, unknown>
+  ).queueList = origQueueList;
+  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
     origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).apply = origApply;
-  (DbService.prototype as Record<string, unknown>).migrate = origMigrate;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (DbService.prototype as Record<string, unknown>).reset = origReset;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).set = origKvSet;
+  (DbService.prototype as unknown as Record<string, unknown>).apply = origApply;
+  (DbService.prototype as unknown as Record<string, unknown>).migrate =
+    origMigrate;
+  (DbService.prototype as unknown as Record<string, unknown>).export =
+    origExport;
+  (DbService.prototype as unknown as Record<string, unknown>).reset = origReset;
+  (
+    KvSyncService.prototype as unknown as Record<string, unknown>
+  ).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).set =
+    origKvSet;
 
   // Fresh mocks
   runSystemCheckMock = mock(async () => ({
@@ -77,30 +83,42 @@ beforeEach(() => {
     data: { url: "https://test-worker.cryptolinx.workers.dev" },
   }));
 
-  (RepairService.prototype as Record<string, unknown>).runSystemCheck =
-    runSystemCheckMock;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = deployMock;
+  (
+    RepairService.prototype as unknown as Record<string, unknown>
+  ).runSystemCheck = runSystemCheckMock;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    deployMock;
 });
 
 afterEach(() => {
   mock.restore();
-  (RepairService.prototype as Record<string, unknown>).runSystemCheck =
-    origRunSystemCheck;
-  (CloudflareService.prototype as Record<string, unknown>).deploy = origDeploy;
-  (CloudflareService.prototype as Record<string, unknown>).d1List = origD1List;
-  (CloudflareService.prototype as Record<string, unknown>).kvList = origKvList;
-  (CloudflareService.prototype as Record<string, unknown>).r2List = origR2List;
-  (CloudflareService.prototype as Record<string, unknown>).queueList =
-    origQueueList;
-  (DbService.prototype as Record<string, unknown>).resolveDbName =
+  (
+    RepairService.prototype as unknown as Record<string, unknown>
+  ).runSystemCheck = origRunSystemCheck;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).deploy =
+    origDeploy;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).d1List =
+    origD1List;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).kvList =
+    origKvList;
+  (CloudflareService.prototype as unknown as Record<string, unknown>).r2List =
+    origR2List;
+  (
+    CloudflareService.prototype as unknown as Record<string, unknown>
+  ).queueList = origQueueList;
+  (DbService.prototype as unknown as Record<string, unknown>).resolveDbName =
     origResolveDbName;
-  (DbService.prototype as Record<string, unknown>).apply = origApply;
-  (DbService.prototype as Record<string, unknown>).migrate = origMigrate;
-  (DbService.prototype as Record<string, unknown>).export = origExport;
-  (DbService.prototype as Record<string, unknown>).reset = origReset;
-  (KvSyncService.prototype as Record<string, unknown>).resolveNamespaceId =
-    origResolveNs;
-  (KvSyncService.prototype as Record<string, unknown>).set = origKvSet;
+  (DbService.prototype as unknown as Record<string, unknown>).apply = origApply;
+  (DbService.prototype as unknown as Record<string, unknown>).migrate =
+    origMigrate;
+  (DbService.prototype as unknown as Record<string, unknown>).export =
+    origExport;
+  (DbService.prototype as unknown as Record<string, unknown>).reset = origReset;
+  (
+    KvSyncService.prototype as unknown as Record<string, unknown>
+  ).resolveNamespaceId = origResolveNs;
+  (KvSyncService.prototype as unknown as Record<string, unknown>).set =
+    origKvSet;
 });
 
 async function importRepairCommand(): Promise<{
@@ -194,8 +212,9 @@ describe("registerRepairCommand", () => {
       runSystemCheckMock = mock(async () => {
         throw new Error("Check failed");
       });
-      (RepairService.prototype as Record<string, unknown>).runSystemCheck =
-        runSystemCheckMock;
+      (
+        RepairService.prototype as unknown as Record<string, unknown>
+      ).runSystemCheck = runSystemCheckMock;
 
       const program = await createProgram();
       await program.parseAsync(["repair", "check"], { from: "user" });

package/src/commands/repair/repair-service.ts

@@ -126,6 +126,32 @@ export class RepairService {
       steps.push({ step: "Secrets", success: false, error: String(err) });
     }
 
+    // Step 6: Worker config schema validation
+    try {
+      const { SchemaService } =
+        await import("../../services/schema/schema-service.js");
+      const svc = new SchemaService();
+      const results = svc.validateAll();
+      const totalErrors = results.reduce(
+        (sum, r) => sum + r.errors.filter((e) => e.severity === "error").length,
+        0
+      );
+      steps.push({
+        step: "Worker config schema",
+        success: totalErrors === 0,
+        message:
+          totalErrors === 0
+            ? "All workers match manifest"
+            : `${totalErrors} schema issue(s) found`,
+      });
+    } catch (err) {
+      steps.push({
+        step: "Worker config schema",
+        success: false,
+        error: String(err),
+      });
+    }
+
     const passed = steps.filter((s) => s.success).length;
     const failed = steps.filter((s) => !s.success).length;
     return {

package/src/commands/schema/index.ts

@@ -0,0 +1 @@
+export { registerSchemaCommand } from "./schema-command.js";

package/src/commands/schema/schema-command.ts

@@ -0,0 +1,137 @@
+import { resolve } from "path";
+import { Command } from "commander";
+import { SchemaService } from "../../services/schema/schema-service.js";
+import {
+  formatSuccess,
+  formatError,
+  formatKeyValue,
+  formatTable,
+  getFormatOptions,
+} from "../../utils/formatters.js";
+import { CLIError, ExitCode } from "../../utils/errors.js";
+import { withErrorHandling } from "../../utils/error-handler.js";
+import {
+  generateWranglerJsonc,
+  generateDevVars,
+} from "@jango-blockchained/hoox-shared";
+
+export function registerSchemaCommand(program: Command): void {
+  const schemaCmd = program
+    .command("schema")
+    .summary("Validate and manage worker configuration")
+    .description(
+      "Validate, generate, and repair worker wrangler.jsonc against canonical manifests."
+    );
+
+  schemaCmd
+    .command("validate [worker]")
+    .description(
+      "Validate worker(s) against manifest (omit worker to validate all)"
+    )
+    .action(
+      withErrorHandling(async (worker?: string) => {
+        const fmt = getFormatOptions(schemaCmd);
+        const svc = new SchemaService();
+        const results = worker
+          ? [svc.validateWorker(worker)]
+          : svc.validateAll();
+        let totalErrors = 0;
+        for (const r of results) {
+          if (r.passed) {
+            formatSuccess(`${r.worker}: ✅ passed`, fmt);
+          } else {
+            formatError(
+              new CLIError(
+                `${r.worker}: ❌ failed (${r.errors.length} issues)`,
+                ExitCode.ERROR
+              ),
+              fmt
+            );
+            for (const e of r.errors.filter((e) => e.severity === "error")) {
+              process.stderr.write(`  ✗ ${e.message}\n`);
+            }
+            totalErrors += r.errors.filter(
+              (e) => e.severity === "error"
+            ).length;
+          }
+        }
+        if (totalErrors > 0) process.exitCode = ExitCode.ERROR;
+      })
+    );
+
+  schemaCmd
+    .command("list")
+    .description("List all workers with their binding counts")
+    .action(
+      withErrorHandling(async () => {
+        const fmt = getFormatOptions(schemaCmd);
+        const svc = new SchemaService();
+        const rows: Record<string, string>[] = [];
+        for (const name of svc.getWorkerNames()) {
+          const m = svc.getManifest(name)!;
+          const secretCount = Object.values(m.vars).filter(
+            (v) => v.type === "secret"
+          ).length;
+          const svcCount = m.services.length;
+          const infraCount = Object.keys(m.infrastructure).length;
+          const middleware = m.middleware.length
+            ? m.middleware.join(", ")
+            : "\u2014";
+          rows.push({
+            worker: name,
+            secrets: String(secretCount),
+            services: String(svcCount),
+            infra: String(infraCount),
+            middleware,
+          });
+        }
+        formatTable(rows, fmt);
+      })
+    );
+
+  schemaCmd
+    .command("generate <worker>")
+    .description("Generate wrangler.jsonc and .dev.vars from manifest")
+    .option("--dry-run", "Print generated content without writing")
+    .action(
+      withErrorHandling(async (worker: string, opts: { dryRun?: boolean }) => {
+        const fmt = getFormatOptions(schemaCmd);
+        const svc = new SchemaService();
+        const manifest = svc.getManifest(worker);
+        if (!manifest) {
+          formatError(
+            new CLIError(`Unknown worker "${worker}"`, ExitCode.INVALID_USAGE),
+            fmt
+          );
+          return;
+        }
+
+        const wranglerContent = generateWranglerJsonc(manifest);
+        const devVarsContent = generateDevVars(manifest);
+
+        if (opts.dryRun) {
+          process.stdout.write(`--- wrangler.jsonc (${worker}) ---\n`);
+          process.stdout.write(wranglerContent + "\n");
+          process.stdout.write(`--- .dev.vars (${worker}) ---\n`);
+          process.stdout.write(devVarsContent + "\n");
+          return;
+        }
+
+        const workersDir = resolve(process.cwd(), "workers", worker);
+        const wranglerPath = resolve(workersDir, "wrangler.jsonc");
+        const devVarsPath = resolve(workersDir, ".dev.vars");
+
+        await Bun.write(wranglerPath, wranglerContent);
+        await Bun.write(devVarsPath, devVarsContent);
+
+        formatKeyValue(
+          {
+            "wrangler.jsonc": wranglerPath,
+            ".dev.vars": devVarsPath,
+          },
+          { ...fmt, json: false }
+        );
+        formatSuccess(`Generated files for ${worker}`, fmt);
+      })
+    );
+}

package/src/commands/test/test-command.test.ts

@@ -1,9 +1,8 @@
-// @ts-nocheck
 import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
 import { Command } from "commander";
 import { registerTestCommand, runStep, printSummary } from "./test-command.js";
-import type { TestStepResult, TestSummary } from "./test-command.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
+import type { TestSummary } from "./test-command.js";
+import { ExitCode } from "../../utils/errors.js";
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/commands/update/update-command.ts

@@ -5,71 +5,12 @@ import { UpdateService } from "../../services/update/index.js";
 import { formatError, getFormatOptions } from "../../utils/formatters.js";
 import { CLIError, ExitCode } from "../../utils/errors.js";
 import { theme } from "../../utils/theme.js";
-
-async function gitPull(cwd: string): Promise<string> {
-  const proc = Bun.spawn(["git", "pull", "--ff-only"], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const exitCode = await proc.exited;
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-
-  if (exitCode !== 0) {
-    throw new Error(stderr.trim() || `git pull failed (exit ${exitCode})`);
-  }
-  return stdout.trim();
-}
-
-async function gitSubmoduleUpdate(
-  cwd: string,
-  submodulePath: string
-): Promise<string> {
-  const proc = Bun.spawn(
-    ["git", "submodule", "update", "--remote", "--init", "--", submodulePath],
-    {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe",
-    }
-  );
-  const exitCode = await proc.exited;
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-
-  if (exitCode !== 0) {
-    throw new Error(
-      stderr.trim() || `git submodule update failed (exit ${exitCode})`
-    );
-  }
-  return stdout.trim();
-}
-
-async function isGitRepo(cwd: string): Promise<boolean> {
-  const proc = Bun.spawn(["git", "rev-parse", "--is-inside-work-tree"], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const exitCode = await proc.exited;
-  return exitCode === 0;
-}
-
-async function isSubmodule(
-  cwd: string,
-  submodulePath: string
-): Promise<boolean> {
-  const proc = Bun.spawn(["git", "submodule", "status", "--", submodulePath], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) return false;
-  const out = (await new Response(proc.stdout).text()).trim();
-  return out.length > 0;
-}
+import {
+  gitPull,
+  gitSubmoduleUpdate,
+  isGitRepo,
+  isSubmodule,
+} from "../../utils/git.js";
 
 export function registerUpdateCommand(program: Command): void {
   program