@clawops/cli 0.2.0

package/dist/chunk-ALSUDYA7.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import {
+  StateError,
+  UsageError
+} from "./chunk-ZSE4QRKE.js";
+
+// src/config/store.ts
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";
+import { randomUUID } from "crypto";
+import os from "os";
+import path from "path";
+import process from "process";
+import { z } from "zod";
+var CredentialsRefSchema = z.object({
+  source: z.enum(["env", "cli-profile", "file", "instance-metadata"]),
+  envVars: z.array(z.string()).optional(),
+  profileName: z.string().optional()
+});
+var LocalOptsSchema = z.object({
+  host: z.string(),
+  sshUser: z.string(),
+  sshPort: z.number(),
+  sshKeyPath: z.string()
+});
+var StackConfigSchema = z.object({
+  provider: z.string(),
+  stateUrl: z.string(),
+  region: z.string().optional(),
+  credentialsRef: CredentialsRefSchema,
+  localOpts: LocalOptsSchema.optional()
+});
+var ClawopsConfigSchema = z.object({
+  version: z.literal(1),
+  defaults: z.object({
+    stack: z.string(),
+    provider: z.string()
+  }),
+  stacks: z.record(StackConfigSchema),
+  ssh: z.object({
+    keyPath: z.string(),
+    knownHostsPath: z.string()
+  }),
+  mcp: z.object({ auditLogPath: z.string() }).optional()
+});
+function getConfigDir() {
+  return process.env["CLAWOPS_HOME"] ?? path.join(os.homedir(), ".clawops");
+}
+function getConfigPath() {
+  return path.join(getConfigDir(), "config.json");
+}
+function getConfig() {
+  try {
+    const raw = readFileSync(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = ClawopsConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new StateError(
+        `Config file is invalid: ${result.error.issues.map((i) => i.message).join(", ")}. Run \`clawops init\` to reinitialise.`
+      );
+    }
+    return result.data;
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function requireConfig() {
+  const cfg = getConfig();
+  if (!cfg) {
+    throw new UsageError("No config found. Run `clawops init` first.");
+  }
+  return cfg;
+}
+function setConfig(config) {
+  const dir = getConfigDir();
+  mkdirSync(dir, { recursive: true });
+  const dest = getConfigPath();
+  const tmp = path.join(dir, `.config.${randomUUID()}.tmp`);
+  writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  renameSync(tmp, dest);
+}
+
+export {
+  getConfigDir,
+  getConfigPath,
+  getConfig,
+  requireConfig,
+  setConfig
+};

package/dist/chunk-ENQY5OW2.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  buildContext
+} from "./chunk-PERSDQMT.js";
+import {
+  validatePlan
+} from "./chunk-YTH4L2GN.js";
+import {
+  getConfig
+} from "./chunk-ALSUDYA7.js";
+import {
+  UsageError
+} from "./chunk-ZSE4QRKE.js";
+
+// src/plan/generate.ts
+import { randomUUID } from "crypto";
+var PREVIEW_LINE_RE = /^([+~-])\s+(\S+)\s+(\S+)?/;
+function parseDiff(lines) {
+  const create = [];
+  const update = [];
+  const del = [];
+  for (const line of lines) {
+    const m = PREVIEW_LINE_RE.exec(line.trimStart());
+    if (!m) continue;
+    const [, op, resourceType, name] = m;
+    const ref = {
+      urn: `urn:pulumi:::clawops::${resourceType}::${name ?? ""}`,
+      type: resourceType,
+      ...name ? { name } : {}
+    };
+    if (op === "+") create.push(ref);
+    else if (op === "~") update.push({ resource: ref, before: null, after: null });
+    else if (op === "-") del.push(ref);
+  }
+  return {
+    create,
+    update,
+    delete: del,
+    totalChanges: create.length + update.length + del.length
+  };
+}
+async function generatePlan(intent, _opts) {
+  if (intent.provider === "local") {
+    throw new UsageError(
+      "plan/apply is not supported for the local provider. Use `clawops up` directly."
+    );
+  }
+  const { version } = await import("./package-YZFYSSQM.js");
+  const config = getConfig();
+  const instanceType = intent.instanceType ?? "small";
+  const openclawVersion = intent.openclawVersion ?? "latest";
+  const network = intent.network ?? {
+    allowedSshCidrs: [],
+    allowedGatewayCidrs: []
+  };
+  const stackName = intent.stackName;
+  const region = intent.region ?? config?.stacks[stackName]?.region;
+  const plan = {
+    apiVersion: "clawops.dev/v1",
+    kind: "DeployPlan",
+    metadata: {
+      name: stackName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generator: "clawops",
+      generatorVersion: version
+    },
+    spec: {
+      provider: intent.provider,
+      region,
+      stackName,
+      instanceType,
+      openclaw: { version: openclawVersion },
+      network,
+      ...intent.tags ? { tags: intent.tags } : {}
+    }
+  };
+  try {
+    const ctx = buildContext({ stack: stackName, provider: intent.provider });
+    const stack = await ctx.getStack();
+    await stack.setConfig("instanceType", { value: instanceType });
+    if (region) await stack.setConfig("region", { value: region });
+    await stack.setConfig("openclawVersion", { value: openclawVersion });
+    const outputLines = [];
+    const preview = await stack.preview({
+      onOutput: (line) => outputLines.push(line)
+    });
+    const diff = parseDiff(outputLines);
+    if (diff.totalChanges === 0 && preview.changeSummary) {
+      const summary = preview.changeSummary;
+      diff.totalChanges = (summary["create"] ?? 0) + (summary["update"] ?? 0) + (summary["delete"] ?? 0);
+    }
+    plan.diff = diff;
+  } catch (err) {
+    process.stderr.write(
+      `[clawops] Warning: preview failed, diff section omitted: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  const validation = validatePlan(plan);
+  if (!validation.ok) {
+    throw new Error(`Generated plan failed schema validation:
+${validation.errors.join("\n")}`);
+  }
+  return plan;
+}
+function planId() {
+  return randomUUID().slice(0, 8);
+}
+
+export {
+  generatePlan,
+  planId
+};

package/dist/chunk-LT24GUUO.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import {
+  StateError
+} from "./chunk-ZSE4QRKE.js";
+
+// src/pulumi/outputs.ts
+function extractBaseOutputs(raw) {
+  const required = [
+    "instanceId",
+    "publicIp",
+    "gatewayUrl",
+    "sshHost",
+    "sshPort",
+    "sshUser",
+    "region",
+    "provisionedAt"
+  ];
+  for (const key of required) {
+    if (raw[key] === void 0 || raw[key] === null) {
+      throw new StateError(
+        `Stack output is missing required field "${key}". The stack may need to be re-deployed with \`clawops up\`.`
+      );
+    }
+  }
+  return {
+    instanceId: String(raw["instanceId"]),
+    publicIp: String(raw["publicIp"]),
+    gatewayUrl: String(raw["gatewayUrl"]),
+    sshHost: String(raw["sshHost"]),
+    sshPort: Number(raw["sshPort"]),
+    sshUser: String(raw["sshUser"]),
+    region: String(raw["region"]),
+    provisionedAt: String(raw["provisionedAt"])
+  };
+}
+
+export {
+  extractBaseOutputs
+};

package/dist/chunk-PERSDQMT.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+  readLocalState
+} from "./chunk-PRYLTCS4.js";
+import {
+  getConfigDir,
+  requireConfig
+} from "./chunk-ALSUDYA7.js";
+import {
+  UsageError
+} from "./chunk-ZSE4QRKE.js";
+
+// src/cli/context.ts
+function buildContext(args) {
+  const config = requireConfig();
+  const stackName = typeof args.stack === "string" ? args.stack : config.defaults.stack;
+  const providerName = typeof args.provider === "string" ? args.provider : config.stacks[stackName]?.provider ?? config.defaults.provider;
+  const adapter = loadProvider(providerName);
+  const localState = providerName === "local" ? readLocalState(stackName) : void 0;
+  let stackCache = null;
+  return {
+    config,
+    adapter,
+    stackName,
+    localState,
+    async getStack() {
+      if (providerName === "local") {
+        throw new UsageError(
+          "The local provider does not use Pulumi stacks. Use `clawops up` to bootstrap the host instead."
+        );
+      }
+      if (stackCache) return stackCache;
+      const stackConfig = config.stacks[stackName];
+      if (!stackConfig) {
+        throw new UsageError(
+          `Stack "${stackName}" not found in config. Run \`clawops init\` or use \`--stack\` to specify a different stack.`
+        );
+      }
+      const { getOrCreateStack } = await import("./automation-JG2YBEL7.js");
+      stackCache = await getOrCreateStack({
+        stack: stackName,
+        stateUrl: stackConfig.stateUrl,
+        program: adapter.program,
+        configDir: getConfigDir()
+      });
+      return stackCache;
+    }
+  };
+}
+function loadProvider(name) {
+  return makeProviderProxy(name);
+}
+function makeProviderProxy(name) {
+  let resolved = null;
+  const resolve = async () => {
+    if (resolved) return resolved;
+    switch (name) {
+      case "gcp": {
+        const mod = await import("./gcp-OHWCTFLL.js");
+        resolved = mod.default;
+        return resolved;
+      }
+      case "aws": {
+        const mod = await import("./aws-A3323GNM.js");
+        resolved = mod.default;
+        return resolved;
+      }
+      case "azure": {
+        const mod = await import("./azure-LNWBK2ZI.js");
+        resolved = mod.default;
+        return resolved;
+      }
+      case "local": {
+        const mod = await import("./local-DXBEVZ5C.js");
+        resolved = mod.default;
+        return resolved;
+      }
+      default:
+        throw new UsageError(
+          `Provider "${name}" is not yet supported. Supported providers: gcp, aws, azure, local`
+        );
+    }
+  };
+  return {
+    name,
+    get program() {
+      return async () => {
+        const adapter = await resolve();
+        return adapter.program();
+      };
+    },
+    getConnectionInfo: (outputs) => {
+      if (!resolved) throw new UsageError("Provider not yet loaded. Call getStack() first.");
+      return resolved.getConnectionInfo(outputs);
+    },
+    normalizeInstanceType: (alias) => {
+      if (!resolved) throw new UsageError("Provider not yet loaded. Call getStack() first.");
+      return resolved.normalizeInstanceType(alias);
+    },
+    defaultRegion: () => {
+      if (!resolved) throw new UsageError("Provider not yet loaded. Call getStack() first.");
+      return resolved.defaultRegion();
+    },
+    stateBackendUrl: (bucket) => {
+      if (!resolved) throw new UsageError("Provider not yet loaded. Call getStack() first.");
+      return resolved.stateBackendUrl(bucket);
+    },
+    validateConfig: () => resolve().then((a) => a.validateConfig())
+  };
+}
+
+export {
+  buildContext
+};

package/dist/chunk-PRYLTCS4.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import {
+  getConfigDir
+} from "./chunk-ALSUDYA7.js";
+
+// src/providers/local/state.ts
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";
+import { randomUUID } from "crypto";
+import path from "path";
+function stateDir() {
+  return path.join(getConfigDir(), "state");
+}
+function statePath(stackName) {
+  return path.join(stateDir(), `${stackName}.json`);
+}
+function readLocalState(stackName) {
+  try {
+    const raw = readFileSync(statePath(stackName), "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function writeLocalState(stackName, state) {
+  const dir = stateDir();
+  mkdirSync(dir, { recursive: true });
+  const dest = statePath(stackName);
+  const tmp = path.join(dir, `.state-${randomUUID()}.tmp`);
+  writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  renameSync(tmp, dest);
+}
+
+export {
+  readLocalState,
+  writeLocalState
+};

package/dist/chunk-RZE35FQF.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import {
+  buildContext
+} from "./chunk-PERSDQMT.js";
+import {
+  validatePlan
+} from "./chunk-YTH4L2GN.js";
+import {
+  UsageError
+} from "./chunk-ZSE4QRKE.js";
+
+// src/plan/apply.ts
+async function applyPlan(plan, opts) {
+  const validation = validatePlan(plan);
+  if (!validation.ok) {
+    throw new UsageError(
+      `Invalid deploy plan:
+${validation.errors.join("\n")}`
+    );
+  }
+  if (plan.spec.provider === "local") {
+    throw new UsageError(
+      "plan/apply is not supported for the local provider. Use `clawops up` directly."
+    );
+  }
+  const ctx = buildContext({
+    stack: plan.spec.stackName,
+    provider: plan.spec.provider
+  });
+  const stack = await ctx.getStack();
+  await stack.setConfig("instanceType", { value: plan.spec.instanceType });
+  if (plan.spec.region) {
+    await stack.setConfig("region", { value: plan.spec.region });
+  }
+  await stack.setConfig("openclawVersion", { value: plan.spec.openclaw.version });
+  const start = Date.now();
+  const result = await stack.up({ onOutput: opts?.onOutput });
+  const outputs = Object.fromEntries(
+    Object.entries(result.outputs).map(([k, v]) => [k, v.value])
+  );
+  const changeSummary = {};
+  if (result.summary.resourceChanges) {
+    for (const [op, count] of Object.entries(result.summary.resourceChanges)) {
+      changeSummary[op] = count;
+    }
+  }
+  return {
+    outputs,
+    changeSummary,
+    durationMs: Date.now() - start
+  };
+}
+
+export {
+  applyPlan
+};

package/dist/chunk-YTH4L2GN.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// src/plan/validate.ts
+import Ajv from "ajv/dist/2020";
+import addFormats from "ajv-formats";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { join, dirname } from "path";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var _validate;
+function getValidator() {
+  if (_validate) return _validate;
+  const ajv = new Ajv({ strict: false });
+  addFormats(ajv);
+  const schema = JSON.parse(
+    readFileSync(join(__dirname, "../../spec/deploy-plan.schema.json"), "utf-8")
+  );
+  _validate = ajv.compile(schema);
+  return _validate;
+}
+function validatePlan(plan) {
+  const validate = getValidator();
+  const ok = validate(plan);
+  if (ok) return { ok: true, errors: [] };
+  const errors = (validate.errors ?? []).map(
+    (e) => `${e.instancePath} ${e.message ?? ""}`.trim()
+  );
+  return { ok: false, errors };
+}
+function assertValidPlan(plan) {
+  const result = validatePlan(plan);
+  if (!result.ok) {
+    throw new Error(`Invalid deploy plan:
+${result.errors.join("\n")}`);
+  }
+}
+
+export {
+  validatePlan,
+  assertValidPlan
+};

package/dist/chunk-ZSE4QRKE.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+// src/errors/index.ts
+var ClawopsError = class extends Error {
+  constructor(message, errorClass, exitCode, retryable = false) {
+    super(message);
+    this.errorClass = errorClass;
+    this.exitCode = exitCode;
+    this.retryable = retryable;
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+  }
+  errorClass;
+  exitCode;
+  retryable;
+};
+var UsageError = class extends ClawopsError {
+  constructor(message) {
+    super(message, "UsageError", 2, false);
+  }
+};
+var StateError = class extends ClawopsError {
+  constructor(message) {
+    super(message, "StateError", 4, false);
+  }
+};
+var ProviderError = class extends ClawopsError {
+  constructor(message, retryable = false) {
+    super(message, "ProviderError", 5, retryable);
+  }
+};
+var NetworkError = class extends ClawopsError {
+  constructor(message) {
+    super(message, "NetworkError", 6, true);
+  }
+};
+
+export {
+  ClawopsError,
+  UsageError,
+  StateError,
+  ProviderError,
+  NetworkError
+};