everything-dev 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "everything-dev",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/src/cli.ts

@@ -213,8 +213,77 @@ async function main() {
     .description("Run CLI as HTTP server (exposes /api)")
     .option("-p, --port <port>", "Port to run on", "4000")
     .action(async (options) => {
-      const result = await client.serve({
-        port: parseInt(options.port, 10),
+      const port = parseInt(options.port, 10);
+      
+      const { Hono } = await import("hono");
+      const { cors } = await import("hono/cors");
+      const { RPCHandler } = await import("@orpc/server/fetch");
+      const { OpenAPIHandler } = await import("@orpc/openapi/fetch");
+      const { OpenAPIReferencePlugin } = await import("@orpc/openapi/plugins");
+      const { ZodToJsonSchemaConverter } = await import("@orpc/zod/zod4");
+      const { onError } = await import("every-plugin/orpc");
+      const { formatORPCError } = await import("every-plugin/errors");
+
+      const app = new Hono();
+      
+      app.use("/*", cors({ origin: "*", credentials: true }));
+
+      const rpcHandler = new RPCHandler(result.router, {
+        interceptors: [onError((error: unknown) => formatORPCError(error))],
+      });
+
+      const apiHandler = new OpenAPIHandler(result.router, {
+        plugins: [
+          new OpenAPIReferencePlugin({
+            schemaConverters: [new ZodToJsonSchemaConverter()],
+            specGenerateOptions: {
+              info: { title: "BOS CLI API", version: "1.0.0" },
+              servers: [{ url: `http://localhost:${port}/api` }],
+            },
+          }),
+        ],
+        interceptors: [onError((error: unknown) => formatORPCError(error))],
+      });
+
+      app.get("/", (c) => c.json({ 
+        ok: true, 
+        plugin: "bos-cli", 
+        status: "ready",
+        endpoints: {
+          health: "/",
+          docs: "/api",
+          rpc: "/api/rpc"
+        }
+      }));
+
+      app.all("/api/rpc/*", async (c) => {
+        const rpcResult = await rpcHandler.handle(c.req.raw, {
+          prefix: "/api/rpc",
+          context: {},
+        });
+        return rpcResult.response 
+          ? new Response(rpcResult.response.body, rpcResult.response) 
+          : c.text("Not Found", 404);
+      });
+
+      app.all("/api", async (c) => {
+        const apiResult = await apiHandler.handle(c.req.raw, {
+          prefix: "/api",
+          context: {},
+        });
+        return apiResult.response 
+          ? new Response(apiResult.response.body, apiResult.response) 
+          : c.text("Not Found", 404);
+      });
+
+      app.all("/api/*", async (c) => {
+        const apiResult = await apiHandler.handle(c.req.raw, {
+          prefix: "/api",
+          context: {},
+        });
+        return apiResult.response 
+          ? new Response(apiResult.response.body, apiResult.response) 
+          : c.text("Not Found", 404);
       });
 
       console.log();
@@ -222,10 +291,27 @@ async function main() {
       console.log(`  ${icons.run} ${gradients.cyber("CLI SERVER")}`);
       console.log(colors.cyan(frames.bottom(48)));
       console.log();
-      console.log(`  ${colors.dim("URL:")}  ${colors.white(result.url)}`);
-      console.log(`  ${colors.dim("RPC:")}  ${colors.white(result.endpoints.rpc)}`);
-      console.log(`  ${colors.dim("Docs:")} ${colors.white(result.endpoints.docs)}`);
+      console.log(`  ${colors.dim("URL:")}  ${colors.white(`http://localhost:${port}`)}`);
+      console.log(`  ${colors.dim("RPC:")}  ${colors.white(`http://localhost:${port}/api/rpc`)}`);
+      console.log(`  ${colors.dim("Docs:")} ${colors.white(`http://localhost:${port}/api`)}`);
       console.log();
+
+      const server = Bun.serve({
+        port,
+        fetch: app.fetch,
+      });
+
+      const shutdown = () => {
+        console.log();
+        console.log(colors.dim("  Shutting down..."));
+        server.stop();
+        process.exit(0);
+      };
+
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+
+      await new Promise(() => {});
     });
 
   program
@@ -659,8 +745,9 @@ Zephyr Configuration:
     .description("Sync dependencies and config from everything-dev CLI")
     .option("--account <account>", "NEAR account to sync from (default: every.near)")
     .option("--gateway <gateway>", "Gateway domain to sync from (default: everything.dev)")
+    .option("--network <network>", "Network: mainnet | testnet", "mainnet")
     .option("--force", "Force sync even if versions match")
-    .action(async (options: { account?: string; gateway?: string; force?: boolean }) => {
+    .action(async (options: { account?: string; gateway?: string; network?: string; force?: boolean }) => {
       console.log();
       const source = options.account || options.gateway 
         ? `${options.account || "every.near"}/${options.gateway || "everything.dev"}`
@@ -670,6 +757,7 @@ Zephyr Configuration:
       const result = await client.sync({
         account: options.account,
         gateway: options.gateway,
+        network: (options.network as "mainnet" | "testnet") || "mainnet",
         force: options.force || false,
       });
 
@@ -746,38 +834,161 @@ Zephyr Configuration:
       console.log();
     });
 
-  depsCmd
-    .command("sync")
-    .description("Sync bos.config.json shared deps to package.json catalog")
-    .argument("[category]", "Dependency category (ui | api)", "ui")
-    .option("--no-install", "Skip running bun install")
-    .action(async (category: string, options: { install: boolean }) => {
+  program
+    .command("kill")
+    .description("Kill all tracked BOS processes")
+    .option("--force", "Force kill with SIGKILL immediately")
+    .action(async (options: { force?: boolean }) => {
+      const result = await client.kill({ force: options.force ?? false });
+
       console.log();
-      console.log(`  ${icons.pkg} Syncing shared.${category} to catalog...`);
+      if (result.status === "error") {
+        console.error(colors.error(`${icons.err} ${result.error || "Failed to kill processes"}`));
+        process.exit(1);
+      }
 
-      const result = await client.depsSync({
-        category: category as "ui" | "api",
-        install: options.install,
+      if (result.killed.length > 0) {
+        console.log(colors.green(`${icons.ok} Killed ${result.killed.length} processes`));
+        for (const pid of result.killed) {
+          console.log(colors.dim(`  PID ${pid}`));
+        }
+      }
+      if (result.failed.length > 0) {
+        console.log(colors.error(`${icons.err} Failed to kill ${result.failed.length} processes`));
+        for (const pid of result.failed) {
+          console.log(colors.dim(`  PID ${pid}`));
+        }
+      }
+      if (result.killed.length === 0 && result.failed.length === 0) {
+        console.log(colors.dim("  No tracked processes found"));
+      }
+      console.log();
+    });
+
+  program
+    .command("ps")
+    .description("List tracked BOS processes")
+    .action(async () => {
+      const result = await client.ps({});
+
+      console.log();
+      console.log(colors.cyan(frames.top(52)));
+      console.log(`  ${icons.run} ${gradients.cyber("PROCESSES")}`);
+      console.log(colors.cyan(frames.bottom(52)));
+      console.log();
+
+      if (result.processes.length === 0) {
+        console.log(colors.dim("  No tracked processes"));
+      } else {
+        for (const proc of result.processes) {
+          const age = Math.round((Date.now() - proc.startedAt) / 1000);
+          console.log(`  ${colors.white(proc.name)} ${colors.dim(`(PID ${proc.pid})`)}`);
+          console.log(`    ${colors.dim("Port:")} ${colors.cyan(String(proc.port))}`);
+          console.log(`    ${colors.dim("Age:")} ${colors.cyan(`${age}s`)}`);
+        }
+      }
+      console.log();
+    });
+
+  const docker = program
+    .command("docker")
+    .description("Docker container management");
+
+  docker
+    .command("build")
+    .description("Build Docker image")
+    .option("-t, --target <target>", "Build target: production | development", "production")
+    .option("--tag <tag>", "Custom image tag")
+    .option("--no-cache", "Build without cache")
+    .action(async (options: { target: string; tag?: string; noCache?: boolean }) => {
+      console.log();
+      console.log(`  ${icons.pkg} Building Docker image (${options.target})...`);
+
+      const result = await client.dockerBuild({
+        target: options.target as "production" | "development",
+        tag: options.tag,
+        noCache: options.noCache ?? false,
       });
 
       if (result.status === "error") {
-        console.error(colors.error(`${icons.err} ${result.error || "Sync failed"}`));
+        console.error(colors.error(`${icons.err} ${result.error || "Build failed"}`));
         process.exit(1);
       }
 
       console.log();
-      console.log(colors.green(`${icons.ok} Synced ${result.synced.length} dependencies to catalog`));
-      
-      if (result.synced.length > 0) {
-        for (const name of result.synced) {
-          console.log(`  ${colors.dim("•")} ${name}`);
+      console.log(colors.green(`${icons.ok} Built ${result.tag}`));
+      console.log();
+    });
+
+  docker
+    .command("run")
+    .description("Run Docker container")
+    .option("-t, --target <target>", "Image target: production | development", "production")
+    .option("-m, --mode <mode>", "Run mode: start | serve | dev", "start")
+    .option("-p, --port <port>", "Port to expose")
+    .option("-d, --detach", "Run in background")
+    .option("-e, --env <env...>", "Environment variables (KEY=value)")
+    .action(async (options: { target: string; mode: string; port?: string; detach?: boolean; env?: string[] }) => {
+      console.log();
+      console.log(`  ${icons.run} Starting Docker container...`);
+
+      const envVars: Record<string, string> = {};
+      if (options.env) {
+        for (const e of options.env) {
+          const [key, ...rest] = e.split("=");
+          if (key) envVars[key] = rest.join("=");
         }
       }
 
-      if (options.install) {
-        console.log(colors.dim("  bun install complete"));
+      const result = await client.dockerRun({
+        target: options.target as "production" | "development",
+        mode: options.mode as "start" | "serve" | "dev",
+        port: options.port ? parseInt(options.port, 10) : undefined,
+        detach: options.detach ?? false,
+        env: Object.keys(envVars).length > 0 ? envVars : undefined,
+      });
+
+      if (result.status === "error") {
+        console.error(colors.error(`${icons.err} ${result.error || "Run failed"}`));
+        process.exit(1);
+      }
+
+      console.log();
+      console.log(colors.green(`${icons.ok} Container running`));
+      console.log(`  ${colors.dim("URL:")} ${colors.cyan(result.url)}`);
+      if (result.containerId !== "attached") {
+        console.log(`  ${colors.dim("Container:")} ${colors.cyan(result.containerId)}`);
+      }
+      console.log();
+    });
+
+  docker
+    .command("stop")
+    .description("Stop Docker container(s)")
+    .option("-c, --container <id>", "Container ID to stop")
+    .option("-a, --all", "Stop all containers for this app")
+    .action(async (options: { container?: string; all?: boolean }) => {
+      console.log();
+      console.log(`  ${icons.pkg} Stopping containers...`);
+
+      const result = await client.dockerStop({
+        containerId: options.container,
+        all: options.all ?? false,
+      });
+
+      if (result.status === "error") {
+        console.error(colors.error(`${icons.err} ${result.error || "Stop failed"}`));
+        process.exit(1);
+      }
+
+      console.log();
+      if (result.stopped.length > 0) {
+        console.log(colors.green(`${icons.ok} Stopped ${result.stopped.length} container(s)`));
+        for (const id of result.stopped) {
+          console.log(colors.dim(`  ${id}`));
+        }
       } else {
-        console.log(colors.dim("  Run 'bun install' to update lockfile"));
+        console.log(colors.dim("  No containers stopped"));
       }
       console.log();
     });

package/src/contract.ts

@@ -2,8 +2,6 @@ import { oc } from "every-plugin/orpc";
 import { z } from "every-plugin/zod";
 import {
   BosConfigSchema,
-  HostConfigSchema,
-  RemoteConfigSchema,
   SourceModeSchema,
 } from "./types";
 
@@ -27,6 +25,7 @@ const StartOptionsSchema = z.object({
   interactive: z.boolean().optional(),
   account: z.string().optional(),
   domain: z.string().optional(),
+  network: z.enum(["mainnet", "testnet"]).default("mainnet"),
 });
 
 const StartResultSchema = z.object({
@@ -215,7 +214,9 @@ const GatewaySyncResultSchema = z.object({
 const SyncOptionsSchema = z.object({
   account: z.string().optional(),
   gateway: z.string().optional(),
+  network: z.enum(["mainnet", "testnet"]).default("mainnet"),
   force: z.boolean().optional(),
+  files: z.boolean().optional(),
 });
 
 const SyncResultSchema = z.object({
@@ -225,6 +226,90 @@ const SyncResultSchema = z.object({
   hostUrl: z.string(),
   catalogUpdated: z.boolean(),
   packagesUpdated: z.array(z.string()),
+  filesSynced: z.array(z.object({
+    package: z.string(),
+    files: z.array(z.string()),
+  })).optional(),
+  error: z.string().optional(),
+});
+
+const FilesSyncOptionsSchema = z.object({
+  packages: z.array(z.string()).optional(),
+  force: z.boolean().optional(),
+});
+
+const FilesSyncResultSchema = z.object({
+  status: z.enum(["synced", "error"]),
+  synced: z.array(z.object({
+    package: z.string(),
+    files: z.array(z.string()),
+    depsAdded: z.array(z.string()).optional(),
+    depsUpdated: z.array(z.string()).optional(),
+  })),
+  error: z.string().optional(),
+});
+
+const KillOptionsSchema = z.object({
+  force: z.boolean().default(false),
+});
+
+const KillResultSchema = z.object({
+  status: z.enum(["killed", "error"]),
+  killed: z.array(z.number()),
+  failed: z.array(z.number()),
+  error: z.string().optional(),
+});
+
+const ProcessStatusSchema = z.object({
+  pid: z.number(),
+  name: z.string(),
+  port: z.number(),
+  startedAt: z.number(),
+  command: z.string(),
+});
+
+const PsResultSchema = z.object({
+  status: z.enum(["listed", "error"]),
+  processes: z.array(ProcessStatusSchema),
+  error: z.string().optional(),
+});
+
+const DockerBuildOptionsSchema = z.object({
+  target: z.enum(["production", "development"]).default("production"),
+  tag: z.string().optional(),
+  noCache: z.boolean().default(false),
+});
+
+const DockerBuildResultSchema = z.object({
+  status: z.enum(["built", "error"]),
+  image: z.string(),
+  tag: z.string(),
+  error: z.string().optional(),
+});
+
+const DockerRunOptionsSchema = z.object({
+  target: z.enum(["production", "development"]).default("production"),
+  mode: z.enum(["start", "serve", "dev"]).default("start"),
+  port: z.number().optional(),
+  detach: z.boolean().default(false),
+  env: z.record(z.string(), z.string()).optional(),
+});
+
+const DockerRunResultSchema = z.object({
+  status: z.enum(["running", "error"]),
+  containerId: z.string(),
+  url: z.string(),
+  error: z.string().optional(),
+});
+
+const DockerStopOptionsSchema = z.object({
+  containerId: z.string().optional(),
+  all: z.boolean().default(false),
+});
+
+const DockerStopResultSchema = z.object({
+  status: z.enum(["stopped", "error"]),
+  stopped: z.array(z.string()),
   error: z.string().optional(),
 });
 
@@ -244,17 +329,6 @@ const DepsUpdateResultSchema = z.object({
   error: z.string().optional(),
 });
 
-const DepsSyncOptionsSchema = z.object({
-  category: z.enum(["ui", "api"]).default("ui"),
-  install: z.boolean().default(true),
-});
-
-const DepsSyncResultSchema = z.object({
-  status: z.enum(["synced", "error"]),
-  synced: z.array(z.string()),
-  error: z.string().optional(),
-});
-
 export const bosContract = oc.router({
   dev: oc
     .route({ method: "POST", path: "/dev" })
@@ -357,10 +431,34 @@ export const bosContract = oc.router({
     .input(DepsUpdateOptionsSchema)
     .output(DepsUpdateResultSchema),
 
-  depsSync: oc
-    .route({ method: "POST", path: "/deps/sync" })
-    .input(DepsSyncOptionsSchema)
-    .output(DepsSyncResultSchema),
+  filesSync: oc
+    .route({ method: "POST", path: "/files/sync" })
+    .input(FilesSyncOptionsSchema)
+    .output(FilesSyncResultSchema),
+
+  kill: oc
+    .route({ method: "POST", path: "/kill" })
+    .input(KillOptionsSchema)
+    .output(KillResultSchema),
+
+  ps: oc
+    .route({ method: "GET", path: "/ps" })
+    .output(PsResultSchema),
+
+  dockerBuild: oc
+    .route({ method: "POST", path: "/docker/build" })
+    .input(DockerBuildOptionsSchema)
+    .output(DockerBuildResultSchema),
+
+  dockerRun: oc
+    .route({ method: "POST", path: "/docker/run" })
+    .input(DockerRunOptionsSchema)
+    .output(DockerRunResultSchema),
+
+  dockerStop: oc
+    .route({ method: "POST", path: "/docker/stop" })
+    .input(DockerStopOptionsSchema)
+    .output(DockerStopResultSchema),
 });
 
 export type BosContract = typeof bosContract;
@@ -397,5 +495,5 @@ export type SyncOptions = z.infer<typeof SyncOptionsSchema>;
 export type SyncResult = z.infer<typeof SyncResultSchema>;
 export type DepsUpdateOptions = z.infer<typeof DepsUpdateOptionsSchema>;
 export type DepsUpdateResult = z.infer<typeof DepsUpdateResultSchema>;
-export type DepsSyncOptions = z.infer<typeof DepsSyncOptionsSchema>;
-export type DepsSyncResult = z.infer<typeof DepsSyncResultSchema>;
+export type FilesSyncOptions = z.infer<typeof FilesSyncOptionsSchema>;
+export type FilesSyncResult = z.infer<typeof FilesSyncResultSchema>;

package/src/lib/nova.ts

@@ -35,7 +35,7 @@ export const getNovaConfig = Effect.gen(function* () {
 
 export function createNovaClient(config: NovaConfig): NovaSdk {
   return new NovaSdk(config.accountId, {
-    sessionToken: config.sessionToken,
+    apiKey: config.sessionToken,
   });
 }
 
@@ -240,7 +240,7 @@ export const removeNovaCredentials = Effect.gen(function* () {
 
 export const verifyNovaCredentials = (accountId: string, sessionToken: string) =>
   Effect.gen(function* () {
-    const nova = new NovaSdk(accountId, { sessionToken });
+    const nova = new NovaSdk(accountId, { apiKey: sessionToken });
 
     yield* Effect.tryPromise({
       try: () => nova.getBalance(),

package/src/lib/process-registry.ts

@@ -0,0 +1,157 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Context, Effect, Layer, Ref } from "every-plugin/effect";
+import { getConfigDir } from "../config";
+
+const getPidFilePath = () => join(getConfigDir(), ".bos", "pids.json");
+
+export interface TrackedProcess {
+  pid: number;
+  name: string;
+  port: number;
+  startedAt: number;
+  command: string;
+}
+
+export interface ProcessRegistry {
+  readonly tracked: Ref.Ref<Map<number, TrackedProcess>>;
+  track: (proc: TrackedProcess) => Effect.Effect<void>;
+  untrack: (pid: number) => Effect.Effect<void>;
+  getAll: () => Effect.Effect<TrackedProcess[]>;
+  killAll: (force?: boolean) => Effect.Effect<{ killed: number[]; failed: number[] }>;
+  persist: () => Effect.Effect<void>;
+  restore: () => Effect.Effect<void>;
+}
+
+const isProcessAlive = (pid: number): boolean => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const killProcess = (pid: number, signal: NodeJS.Signals): boolean => {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const make = Effect.gen(function* () {
+  const tracked = yield* Ref.make(new Map<number, TrackedProcess>());
+  const pidFile = getPidFilePath();
+
+  const track: ProcessRegistry["track"] = (proc) =>
+    Effect.gen(function* () {
+      yield* Ref.update(tracked, (m) => new Map(m).set(proc.pid, proc));
+      yield* persist();
+    });
+
+  const untrack: ProcessRegistry["untrack"] = (pid) =>
+    Effect.gen(function* () {
+      yield* Ref.update(tracked, (m) => {
+        const copy = new Map(m);
+        copy.delete(pid);
+        return copy;
+      });
+      yield* persist();
+    });
+
+  const getAll: ProcessRegistry["getAll"] = () =>
+    Ref.get(tracked).pipe(Effect.map((m) => Array.from(m.values())));
+
+  const killAll: ProcessRegistry["killAll"] = (force = false) =>
+    Effect.gen(function* () {
+      const procs = yield* getAll();
+      const killed: number[] = [];
+      const failed: number[] = [];
+
+      for (const proc of procs) {
+        if (!isProcessAlive(proc.pid)) {
+          yield* untrack(proc.pid);
+          continue;
+        }
+
+        const signal = force ? "SIGKILL" : "SIGTERM";
+        if (killProcess(proc.pid, signal)) {
+          killed.push(proc.pid);
+          yield* untrack(proc.pid);
+        } else {
+          failed.push(proc.pid);
+        }
+      }
+
+      if (!force && failed.length > 0) {
+        yield* Effect.sleep("500 millis");
+        for (const pid of [...failed]) {
+          if (killProcess(pid, "SIGKILL")) {
+            const idx = failed.indexOf(pid);
+            if (idx !== -1) {
+              failed.splice(idx, 1);
+              killed.push(pid);
+            }
+            yield* untrack(pid);
+          }
+        }
+      }
+
+      yield* persist();
+      return { killed, failed };
+    });
+
+  const persist: ProcessRegistry["persist"] = () =>
+    Effect.gen(function* () {
+      const procs = yield* getAll();
+      const dir = dirname(pidFile);
+      
+      yield* Effect.tryPromise({
+        try: async () => {
+          if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+          }
+          await writeFile(pidFile, JSON.stringify(procs, null, 2));
+        },
+        catch: () => new Error("Failed to persist PIDs"),
+      }).pipe(Effect.catchAll(() => Effect.void));
+    });
+
+  const restore: ProcessRegistry["restore"] = () =>
+    Effect.gen(function* () {
+      if (!existsSync(pidFile)) return;
+
+      const content = yield* Effect.tryPromise({
+        try: () => readFile(pidFile, "utf8"),
+        catch: () => new Error("Failed to read PID file"),
+      }).pipe(Effect.catchAll(() => Effect.succeed("")));
+
+      if (!content) return;
+
+      let procs: TrackedProcess[];
+      try {
+        procs = JSON.parse(content) as TrackedProcess[];
+      } catch {
+        return;
+      }
+
+      const alive = procs.filter((p) => isProcessAlive(p.pid));
+      yield* Ref.set(tracked, new Map(alive.map((p) => [p.pid, p])));
+    });
+
+  yield* restore();
+
+  return { tracked, track, untrack, getAll, killAll, persist, restore };
+});
+
+export class ProcessRegistryService extends Context.Tag("bos/ProcessRegistry")<
+  ProcessRegistryService,
+  ProcessRegistry
+>() {
+  static Live = Layer.effect(ProcessRegistryService, make);
+}
+
+export const createProcessRegistry = (): Effect.Effect<ProcessRegistry> => make;

package/src/lib/secrets.ts

@@ -2,6 +2,7 @@ import { loadConfig } from "../config";
 
 export function loadSecretsFor(component: string): Record<string, string> {
   const config = loadConfig();
+  if (!config) return {};
   const componentConfig = config.app[component];
   if (!componentConfig) return {};