everything-dev 1.27.0 → 1.28.1

package/src/contract.meta.ts

@@ -1,140 +0,0 @@
-export type CliCommandMeta = {
-  commandPath?: string[];
-  summary: string;
-  description?: string;
-  examples?: string[];
-  interactive?: boolean;
-  longRunning?: boolean;
-  fields?: Record<string, { positional?: boolean; description?: string }>;
-};
-
-export const cliCommandMeta = {
-  dev: {
-    commandPath: ["dev"],
-    summary: "Start a development session",
-    interactive: true,
-    longRunning: true,
-  },
-  start: {
-    commandPath: ["start"],
-    summary: "Start the production host",
-    interactive: false,
-    longRunning: true,
-    fields: {
-      env: { description: "Environment: production or staging" },
-    },
-  },
-  build: {
-    commandPath: ["build"],
-    summary: "Build selected workspaces",
-    interactive: false,
-    fields: {
-      packages: { positional: true, description: "Comma-separated package list" },
-    },
-  },
-  config: {
-    commandPath: ["config"],
-    summary: "Print the loaded BOS configuration",
-    interactive: false,
-  },
-  pluginAdd: {
-    commandPath: ["plugin", "add"],
-    summary: "Add a plugin attachment",
-    interactive: false,
-    fields: {
-      source: {
-        positional: true,
-        description: "Plugin source (local:path, bos://account/domain, or URL)",
-      },
-      as: { description: "Plugin alias" },
-      production: { description: "Production URL override" },
-    },
-  },
-  pluginRemove: {
-    commandPath: ["plugin", "remove"],
-    summary: "Remove a plugin attachment",
-    interactive: false,
-    fields: { key: { positional: true, description: "Plugin key" } },
-  },
-  pluginList: {
-    commandPath: ["plugin", "list"],
-    summary: "List configured plugins",
-    interactive: false,
-  },
-  pluginPublish: {
-    commandPath: ["plugin", "publish"],
-    summary: "Publish a single plugin",
-    interactive: false,
-    fields: { key: { positional: true, description: "Plugin key" } },
-  },
-  publish: {
-    commandPath: ["publish"],
-    summary: "Publish the current workspace configuration",
-    interactive: false,
-  },
-  keyPublish: {
-    commandPath: ["key", "publish"],
-    summary: "Generate a publish access key",
-    interactive: false,
-  },
-  init: {
-    commandPath: ["init"],
-    summary: "Scaffold a new project by extending a deployed app or template",
-    interactive: true,
-    fields: {
-      domain: {
-        positional: true,
-        description: "New project domain (e.g. myapp.everything.dev)",
-      },
-      extends: {
-        description: "Parent to extend from (e.g. bos://account/gateway or account/gateway)",
-      },
-      account: { description: "New project NEAR account (auto-derived from extends)" },
-      directory: { description: "Target directory (auto-derived from domain)" },
-      source: { description: "Local source dir (skips GitHub download)" },
-      plugins: {
-        description: "Comma-separated plugin keys to include (requires --overrides=plugins)",
-      },
-      overrides: {
-        description: "Comma-separated sections to customize locally: ui,api,host,plugins",
-      },
-      noInteractive: { description: "Skip prompts, use flags only" },
-      noInstall: { description: "Skip bun install" },
-    },
-  },
-  sync: {
-    commandPath: ["sync"],
-    summary: "Sync template files from parent project",
-    interactive: false,
-    fields: {
-      dryRun: { description: "Preview changes without writing files" },
-      force: { description: "Overwrite user-modified files" },
-      noInstall: { description: "Skip bun install" },
-    },
-  },
-  upgrade: {
-    commandPath: ["upgrade"],
-    summary: "Upgrade framework packages and sync template files",
-    interactive: true,
-    fields: {
-      dryRun: { description: "Preview changes without writing" },
-      force: { description: "Overwrite user-modified files during sync" },
-      noInstall: { description: "Skip bun install" },
-      noSync: { description: "Only upgrade packages, skip template sync" },
-    },
-  },
-  typesGen: {
-    commandPath: ["types", "gen"],
-    summary: "Generate type definitions from configured API and plugin contracts",
-    interactive: false,
-    fields: {
-      env: { description: "Environment: development (default) or production" },
-      dryRun: { description: "Preview what would be fetched without writing files" },
-    },
-  },
-  status: {
-    commandPath: ["status"],
-    summary: "Show project health, versions, and update availability",
-    interactive: false,
-  },
-} as const satisfies Record<string, CliCommandMeta>;

package/src/contract.ts

@@ -1,326 +0,0 @@
-import * as z from "zod";
-import { oc } from "./sdk";
-import { BosConfigSchema, SourceModeSchema } from "./types";
-
-export const DevOptionsSchema = z.object({
-  host: SourceModeSchema.default("local"),
-  ui: SourceModeSchema.default("local"),
-  api: SourceModeSchema.default("local"),
-  auth: SourceModeSchema.default("local"),
-  proxy: z.boolean().default(false),
-  ssr: z.boolean().default(false),
-  port: z.number().optional(),
-  interactive: z.boolean().optional(),
-});
-
-export const DevResultSchema = z.object({
-  status: z.enum(["started", "error"]),
-  description: z.string(),
-  processes: z.array(z.string()),
-});
-
-export const StartOptionsSchema = z.object({
-  port: z.number().optional(),
-  interactive: z.boolean().optional(),
-  account: z.string().optional(),
-  domain: z.string().optional(),
-  env: z.enum(["production", "staging"]).default("production"),
-});
-
-export const StartResultSchema = z.object({
-  status: z.enum(["running", "error"]),
-  url: z.string(),
-  error: z.string().optional(),
-});
-
-export const BuildOptionsSchema = z.object({
-  packages: z.string().default("all"),
-  force: z.boolean().default(false),
-  deploy: z.boolean().default(false),
-});
-
-export const BuildResultSchema = z.object({
-  status: z.enum(["success", "error"]),
-  built: z.array(z.string()),
-  skipped: z.array(z.string()).optional(),
-  deployed: z.boolean().optional(),
-});
-
-export const ConfigResultSchema = z.object({
-  config: BosConfigSchema.nullable(),
-  packages: z.array(z.string()),
-  remotes: z.array(z.string()),
-});
-
-export const PluginAddOptionsSchema = z.object({
-  source: z.string(),
-  as: z.string().optional(),
-  production: z.string().optional(),
-});
-
-export const PluginAddResultSchema = z.object({
-  status: z.enum(["added", "error"]),
-  key: z.string(),
-  development: z.string().optional(),
-  production: z.string().optional(),
-  integrity: z.string().optional(),
-  version: z.string().optional(),
-  error: z.string().optional(),
-});
-
-export const PluginRemoveOptionsSchema = z.object({
-  key: z.string(),
-});
-
-export const PluginRemoveResultSchema = z.object({
-  status: z.enum(["removed", "error"]),
-  key: z.string(),
-  error: z.string().optional(),
-});
-
-export const PluginListResultSchema = z.object({
-  status: z.enum(["listed", "error"]),
-  plugins: z.array(
-    z.object({
-      key: z.string(),
-      development: z.string().optional(),
-      production: z.string().optional(),
-      localPath: z.string().optional(),
-      source: z.enum(["local", "remote"]),
-      integrity: z.string().optional(),
-      version: z.string().optional(),
-      name: z.string().optional(),
-    }),
-  ),
-  error: z.string().optional(),
-});
-
-export const PluginPublishOptionsSchema = z.object({
-  key: z.string(),
-});
-
-export const PluginPublishResultSchema = z.object({
-  status: z.enum(["published", "error"]),
-  key: z.string(),
-  path: z.string().optional(),
-  script: z.string().optional(),
-  production: z.string().optional(),
-  integrity: z.string().optional(),
-  version: z.string().optional(),
-  error: z.string().optional(),
-});
-
-export const PublishOptionsSchema = z.object({
-  deploy: z.boolean().default(false),
-  dryRun: z.boolean().default(false),
-  packages: z.string().default("all"),
-  network: z.enum(["mainnet", "testnet"]).optional(),
-  privateKey: z.string().optional(),
-});
-
-export const PublishResultSchema = z.object({
-  status: z.enum(["published", "error", "dry-run"]),
-  registryUrl: z.string(),
-  txHash: z.string().optional(),
-  error: z.string().optional(),
-  built: z.array(z.string()).optional(),
-  skipped: z.array(z.string()).optional(),
-});
-
-export const KeyPublishOptionsSchema = z.object({
-  allowance: z.string().default("0.25NEAR"),
-});
-
-export const KeyPublishResultSchema = z.object({
-  status: z.enum(["published", "error"]),
-  account: z.string(),
-  network: z.enum(["mainnet", "testnet"]),
-  contract: z.string(),
-  allowance: z.string(),
-  functionNames: z.array(z.string()),
-  publicKey: z.string().optional(),
-  privateKey: z.string().optional(),
-  error: z.string().optional(),
-});
-
-export const OverrideSectionSchema = z.enum(["ui", "api", "host", "plugins"]);
-
-export const InitOptionsSchema = z.object({
-  extends: z.string().optional(),
-  directory: z.string().optional(),
-  account: z.string().optional(),
-  domain: z.string().optional(),
-  source: z.string().optional(),
-  plugins: z.array(z.string()).optional(),
-  overrides: z.array(OverrideSectionSchema).optional(),
-  noInteractive: z.boolean().default(false),
-  noInstall: z.boolean().default(false),
-});
-
-export const PhaseTimingSchema = z.object({
-  name: z.string(),
-  durationMs: z.number(),
-});
-
-export const InitResultSchema = z.object({
-  status: z.enum(["initialized", "error"]),
-  directory: z.string(),
-  extendsRef: z.string(),
-  account: z.string().optional(),
-  domain: z.string().optional(),
-  extends: z.string(),
-  plugins: z.array(z.string()).optional(),
-  overrides: z.array(OverrideSectionSchema).optional(),
-  filesCopied: z.number(),
-  timings: z.array(PhaseTimingSchema).optional(),
-  error: z.string().optional(),
-});
-
-export const SyncOptionsSchema = z.object({
-  dryRun: z.boolean().default(false),
-  force: z.boolean().default(false),
-  noInstall: z.boolean().default(false),
-});
-
-export const SyncResultSchema = z.object({
-  status: z.enum(["synced", "dry-run", "error"]),
-  updated: z.array(z.string()),
-  skipped: z.array(z.string()),
-  added: z.array(z.string()),
-  error: z.string().optional(),
-});
-
-export const UpgradeOptionsSchema = z.object({
-  dryRun: z.boolean().default(false),
-  force: z.boolean().default(false),
-  noInstall: z.boolean().default(false),
-  noSync: z.boolean().default(false),
-});
-
-export const UpgradeResultSchema = z.object({
-  status: z.enum(["upgraded", "dry-run", "error"]),
-  packages: z.array(
-    z.object({
-      name: z.string(),
-      from: z.string().optional(),
-      to: z.string(),
-    }),
-  ),
-  sync: SyncResultSchema.optional(),
-  migrated: z.array(z.string()).optional(),
-  availablePlugins: z.array(z.string()).optional(),
-  selectedPlugins: z.array(z.string()).optional(),
-  timings: z.array(PhaseTimingSchema).optional(),
-  changelogUrl: z.string().optional(),
-  error: z.string().optional(),
-});
-
-export const StatusResultSchema = z.object({
-  status: z.enum(["ok", "error"]),
-  extends: z.string().optional(),
-  account: z.string().optional(),
-  domain: z.string().optional(),
-  packages: z.array(
-    z.object({
-      name: z.string(),
-      installed: z.string().optional(),
-      latest: z.string().optional(),
-    }),
-  ),
-  lastSync: z.string().optional(),
-  envFile: z.enum(["found", "missing", "example-only"]),
-  parentReachable: z.boolean().optional(),
-  error: z.string().optional(),
-});
-
-export const TypesGenOptionsSchema = z.object({
-  env: z.enum(["development", "production"]).optional(),
-  dryRun: z.boolean().default(false),
-});
-
-export const TypesGenResultSchema = z.object({
-  status: z.enum(["success", "error"]),
-  generated: z.array(z.string()),
-  fetched: z.array(z.string()),
-  skipped: z.array(z.string()),
-  failed: z.array(z.string()),
-  source: z.enum(["local", "remote"]).optional(),
-  error: z.string().optional(),
-});
-
-export const bosContract = oc.router({
-  dev: oc.route({ method: "POST", path: "/dev" }).input(DevOptionsSchema).output(DevResultSchema),
-  start: oc
-    .route({ method: "POST", path: "/start" })
-    .input(StartOptionsSchema)
-    .output(StartResultSchema),
-  build: oc
-    .route({ method: "POST", path: "/build" })
-    .input(BuildOptionsSchema)
-    .output(BuildResultSchema),
-  config: oc.route({ method: "GET", path: "/config" }).output(ConfigResultSchema),
-  pluginAdd: oc
-    .route({ method: "POST", path: "/plugin/add" })
-    .input(PluginAddOptionsSchema)
-    .output(PluginAddResultSchema),
-  pluginRemove: oc
-    .route({ method: "POST", path: "/plugin/remove" })
-    .input(PluginRemoveOptionsSchema)
-    .output(PluginRemoveResultSchema),
-  pluginList: oc.route({ method: "GET", path: "/plugin/list" }).output(PluginListResultSchema),
-  pluginPublish: oc
-    .route({ method: "POST", path: "/plugin/publish" })
-    .input(PluginPublishOptionsSchema)
-    .output(PluginPublishResultSchema),
-  publish: oc
-    .route({ method: "POST", path: "/publish" })
-    .input(PublishOptionsSchema)
-    .output(PublishResultSchema),
-  keyPublish: oc
-    .route({ method: "POST", path: "/key/publish" })
-    .input(KeyPublishOptionsSchema)
-    .output(KeyPublishResultSchema),
-  init: oc
-    .route({ method: "POST", path: "/init" })
-    .input(InitOptionsSchema)
-    .output(InitResultSchema),
-  sync: oc
-    .route({ method: "POST", path: "/sync" })
-    .input(SyncOptionsSchema)
-    .output(SyncResultSchema),
-  upgrade: oc
-    .route({ method: "POST", path: "/upgrade" })
-    .input(UpgradeOptionsSchema)
-    .output(UpgradeResultSchema),
-  status: oc.route({ method: "GET", path: "/status" }).output(StatusResultSchema),
-  typesGen: oc
-    .route({ method: "POST", path: "/types/gen" })
-    .input(TypesGenOptionsSchema)
-    .output(TypesGenResultSchema),
-});
-
-export type DevOptions = z.infer<typeof DevOptionsSchema>;
-export type StartOptions = z.infer<typeof StartOptionsSchema>;
-export type BuildOptions = z.infer<typeof BuildOptionsSchema>;
-export type BosConfigResult = z.infer<typeof ConfigResultSchema>;
-export type PluginAddOptions = z.infer<typeof PluginAddOptionsSchema>;
-export type PluginAddResult = z.infer<typeof PluginAddResultSchema>;
-export type PluginRemoveOptions = z.infer<typeof PluginRemoveOptionsSchema>;
-export type PluginRemoveResult = z.infer<typeof PluginRemoveResultSchema>;
-export type PluginListResult = z.infer<typeof PluginListResultSchema>;
-export type PluginPublishOptions = z.infer<typeof PluginPublishOptionsSchema>;
-export type PluginPublishResult = z.infer<typeof PluginPublishResultSchema>;
-export type PublishOptions = z.infer<typeof PublishOptionsSchema>;
-export type KeyPublishOptions = z.infer<typeof KeyPublishOptionsSchema>;
-export type KeyPublishResult = z.infer<typeof KeyPublishResultSchema>;
-export type InitOptions = z.infer<typeof InitOptionsSchema>;
-export type InitResult = z.infer<typeof InitResultSchema>;
-export type OverrideSection = z.infer<typeof OverrideSectionSchema>;
-export type PhaseTiming = z.infer<typeof PhaseTimingSchema>;
-export type SyncOptions = z.infer<typeof SyncOptionsSchema>;
-export type SyncResult = z.infer<typeof SyncResultSchema>;
-export type UpgradeOptions = z.infer<typeof UpgradeOptionsSchema>;
-export type UpgradeResult = z.infer<typeof UpgradeResultSchema>;
-export type StatusResult = z.infer<typeof StatusResultSchema>;
-export type TypesGenOptions = z.infer<typeof TypesGenOptionsSchema>;
-export type TypesGenResult = z.infer<typeof TypesGenResultSchema>;

package/src/dev-logs.ts

@@ -1,92 +0,0 @@
-import { existsSync } from "node:fs";
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const ESC = "\x1b";
-const BEL = "\x07";
-const ANSI_RE = new RegExp(`${ESC}\\[[0-?]*[ -/]*[@-~]|${ESC}\\][^${BEL}]*${BEL}`, "g");
-
-const stripAnsi = (input: string): string => input.replace(ANSI_RE, "");
-
-export interface LogEntry {
-  timestamp: number;
-  source: string;
-  line: string;
-  isError?: boolean;
-}
-
-export interface DevLogger {
-  logFile: string;
-  latestFile: string;
-  write: (entry: LogEntry) => Promise<void>;
-  readLatest: (opts?: { tail?: number }) => Promise<string>;
-}
-
-export function getBosDir(configDir: string): string {
-  return join(configDir, ".bos");
-}
-
-export function getLogsDir(configDir: string): string {
-  return join(getBosDir(configDir), "logs");
-}
-
-function formatLogLine(entry: LogEntry): string {
-  const ts = new Date(entry.timestamp).toISOString();
-  const prefix = entry.isError ? "ERR" : "OUT";
-  const clean = stripAnsi(entry.line);
-  return `[${ts}] [${entry.source}] [${prefix}] ${clean}`;
-}
-
-export async function createDevLogger(configDir: string, description: string): Promise<DevLogger> {
-  const dir = getLogsDir(configDir);
-  if (!existsSync(dir)) {
-    await mkdir(dir, { recursive: true });
-  }
-
-  const now = new Date();
-  const ts = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const logFile = join(dir, `dev-${ts}.log`);
-  const latestFile = join(dir, "dev-latest.log");
-
-  const header =
-    `# everything-dev dev session: ${description}\n` + `# Started: ${now.toISOString()}\n\n`;
-  // Overwrite each run so dev-latest.log is always actionable.
-  await writeFile(logFile, header, "utf8");
-  await writeFile(latestFile, header, "utf8");
-
-  let chain = Promise.resolve();
-  const enqueue = (fn: () => Promise<void>) => {
-    chain = chain.then(fn, fn);
-    return chain;
-  };
-
-  return {
-    logFile,
-    latestFile,
-    write: (entry) =>
-      enqueue(async () => {
-        const line = `${formatLogLine(entry)}\n`;
-        await appendFile(logFile, line);
-        await appendFile(latestFile, line);
-      }),
-    readLatest: async (opts) => {
-      const text = await readFile(latestFile, "utf8").catch(() => "");
-      const tail = opts?.tail;
-      if (!tail || tail <= 0) return text;
-      const lines = text.split("\n");
-      return lines.slice(Math.max(0, lines.length - tail)).join("\n");
-    },
-  };
-}
-
-export async function readDevLatestLog(
-  configDir: string,
-  opts?: { tail?: number },
-): Promise<string> {
-  const latestFile = join(getLogsDir(configDir), "dev-latest.log");
-  const text = await readFile(latestFile, "utf8").catch(() => "");
-  const tail = opts?.tail;
-  if (!tail || tail <= 0) return text;
-  const lines = text.split("\n");
-  return lines.slice(Math.max(0, lines.length - tail)).join("\n");
-}