@semiont/cli 0.3.0 → 0.3.1

package/dist/cli.mjs

@@ -512,8 +512,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path45, errorMaps, issueData } = params;
-      const fullPath = [...path45, ...issueData.path || []];
+      const { data, path: path46, errorMaps, issueData } = params;
+      const fullPath = [...path46, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -821,11 +821,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path45, key) {
+      constructor(parent, value, path46, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path45;
+        this._path = path46;
         this._key = key;
       }
       get path() {
@@ -5626,8 +5626,8 @@ var init_filesystem_service = __esm({
       async checkHealth() {
         const dataPath = this.getDataPath();
         try {
-          const fs53 = await import("fs");
-          await fs53.promises.access(dataPath, fs53.constants.R_OK | fs53.constants.W_OK);
+          const fs54 = await import("fs");
+          await fs54.promises.access(dataPath, fs54.constants.R_OK | fs54.constants.W_OK);
           return {
             healthy: true,
             details: {
@@ -7157,11 +7157,11 @@ var init_backend_check = __esm({
       let logs;
       if (fs11.existsSync(appLogPath)) {
         try {
-          const { execFileSync: execFileSync44 } = __require("child_process");
-          const recentLogs = execFileSync44("tail", ["-10", appLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
+          const { execFileSync: execFileSync45 } = __require("child_process");
+          const recentLogs = execFileSync45("tail", ["-10", appLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
           let errorLogs = [];
           if (fs11.existsSync(errorLogPath)) {
-            errorLogs = execFileSync44("tail", ["-5", errorLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
+            errorLogs = execFileSync45("tail", ["-5", errorLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
           }
           logs = {
             recent: recentLogs,
@@ -7377,11 +7377,11 @@ var init_frontend_check = __esm({
       let logs;
       if (fs12.existsSync(appLogPath)) {
         try {
-          const { execFileSync: execFileSync44 } = __require("child_process");
-          const recentLogs = execFileSync44("tail", ["-10", appLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
+          const { execFileSync: execFileSync45 } = __require("child_process");
+          const recentLogs = execFileSync45("tail", ["-10", appLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
           let errorLogs = [];
           if (fs12.existsSync(errorLogPath)) {
-            errorLogs = execFileSync44("tail", ["-5", errorLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
+            errorLogs = execFileSync45("tail", ["-5", errorLogPath], { encoding: "utf-8" }).split("\n").filter((line) => line.trim());
           }
           logs = {
             recent: recentLogs,
@@ -8029,8 +8029,8 @@ async function startJanusGraph(context) {
   for (let i = 0; i < maxAttempts; i++) {
     await new Promise((resolve9) => setTimeout(resolve9, 2e3));
     try {
-      const { execFileSync: execFileSync44 } = await import("child_process");
-      execFileSync44(gremlinShellScript, ["-e", "g.V().count()"], {
+      const { execFileSync: execFileSync45 } = await import("child_process");
+      execFileSync45(gremlinShellScript, ["-e", "g.V().count()"], {
         stdio: "ignore",
         timeout: 5e3
       });
@@ -8081,9 +8081,9 @@ async function startJanusGraph(context) {
     }
   };
 }
-async function fileExists(path45) {
+async function fileExists(path46) {
   try {
-    await fs17.access(path45);
+    await fs17.access(path46);
     return true;
   } catch {
     return false;
@@ -8911,8 +8911,8 @@ var init_filesystem_provision = __esm({
           metadata.directories.push(dirPath);
         }
         try {
-          const { execFileSync: execFileSync44 } = __require("child_process");
-          const dfOutput = execFileSync44("df", ["-h", absolutePath], { encoding: "utf-8" });
+          const { execFileSync: execFileSync45 } = __require("child_process");
+          const dfOutput = execFileSync45("df", ["-h", absolutePath], { encoding: "utf-8" });
           const lines = dfOutput.split("\n");
           if (lines.length > 1) {
             const stats = lines[1].split(/\s+/);
@@ -9017,9 +9017,9 @@ Files placed here will persist across service restarts.
 // src/platforms/posix/handlers/graph-provision.ts
 import * as fs23 from "fs/promises";
 import { execFileSync as execFileSync9 } from "child_process";
-async function fileExists2(path45) {
+async function fileExists2(path46) {
   try {
-    await fs23.access(path45);
+    await fs23.access(path46);
     return true;
   } catch {
     return false;
@@ -10268,9 +10268,9 @@ async function stopJanusGraph(context) {
     };
   }
 }
-async function fileExists3(path45) {
+async function fileExists3(path46) {
   try {
-    await fs27.access(path45);
+    await fs27.access(path46);
     return true;
   } catch {
     return false;
@@ -12801,9 +12801,9 @@ async function startJanusGraph2(context) {
     };
   }
 }
-async function fileExists4(path45) {
+async function fileExists4(path46) {
   try {
-    await fs36.access(path45);
+    await fs36.access(path46);
     return true;
   } catch {
     return false;
@@ -15956,9 +15956,9 @@ async function stopJanusGraph2(context) {
     };
   }
 }
-async function fileExists5(path45) {
+async function fileExists5(path46) {
   try {
-    await fs39.access(path45);
+    await fs39.access(path46);
     return true;
   } catch {
     return false;
@@ -22006,12 +22006,12 @@ var init_path = __esm({
   "node_modules/@anthropic-ai/sdk/internal/utils/path.mjs"() {
     init_error();
     EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-    createPathTagFunction = (pathEncoder = encodeURIPath) => function path45(statics, ...params) {
+    createPathTagFunction = (pathEncoder = encodeURIPath) => function path46(statics, ...params) {
       if (statics.length === 1)
         return statics[0];
       let postPath = false;
       const invalidSegments = [];
-      const path46 = statics.reduce((previousValue, currentValue, index) => {
+      const path47 = statics.reduce((previousValue, currentValue, index) => {
         if (/[?#]/.test(currentValue)) {
           postPath = true;
         }
@@ -22028,7 +22028,7 @@ var init_path = __esm({
         }
         return previousValue + currentValue + (index === params.length ? "" : encoded);
       }, "");
-      const pathOnly = path46.split(/[?#]/, 1)[0];
+      const pathOnly = path47.split(/[?#]/, 1)[0];
       const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
       let match;
       while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -22049,10 +22049,10 @@ var init_path = __esm({
         }, "");
         throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path46}
+${path47}
 ${underline}`);
       }
-      return path46;
+      return path47;
     };
     path34 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
   }
@@ -24735,9 +24735,9 @@ var init_client = __esm({
       makeStatusError(status, error, message, headers) {
         return APIError.generate(status, error, message, headers);
       }
-      buildURL(path45, query, defaultBaseURL) {
+      buildURL(path46, query, defaultBaseURL) {
         const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-        const url = isAbsoluteURL(path45) ? new URL(path45) : new URL(baseURL + (baseURL.endsWith("/") && path45.startsWith("/") ? path45.slice(1) : path45));
+        const url = isAbsoluteURL(path46) ? new URL(path46) : new URL(baseURL + (baseURL.endsWith("/") && path46.startsWith("/") ? path46.slice(1) : path46));
         const defaultQuery = this.defaultQuery();
         if (!isEmptyObj(defaultQuery)) {
           query = { ...defaultQuery, ...query };
@@ -24768,24 +24768,24 @@ var init_client = __esm({
        */
       async prepareRequest(request, { url, options }) {
       }
-      get(path45, opts) {
-        return this.methodRequest("get", path45, opts);
+      get(path46, opts) {
+        return this.methodRequest("get", path46, opts);
       }
-      post(path45, opts) {
-        return this.methodRequest("post", path45, opts);
+      post(path46, opts) {
+        return this.methodRequest("post", path46, opts);
       }
-      patch(path45, opts) {
-        return this.methodRequest("patch", path45, opts);
+      patch(path46, opts) {
+        return this.methodRequest("patch", path46, opts);
       }
-      put(path45, opts) {
-        return this.methodRequest("put", path45, opts);
+      put(path46, opts) {
+        return this.methodRequest("put", path46, opts);
       }
-      delete(path45, opts) {
-        return this.methodRequest("delete", path45, opts);
+      delete(path46, opts) {
+        return this.methodRequest("delete", path46, opts);
       }
-      methodRequest(method, path45, opts) {
+      methodRequest(method, path46, opts) {
         return this.request(Promise.resolve(opts).then((opts2) => {
-          return { method, path: path45, ...opts2 };
+          return { method, path: path46, ...opts2 };
         }));
       }
       request(options, remainingRetries = null) {
@@ -24889,8 +24889,8 @@ var init_client = __esm({
         }));
         return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
       }
-      getAPIList(path45, Page2, opts) {
-        return this.requestAPIList(Page2, { method: "get", path: path45, ...opts });
+      getAPIList(path46, Page2, opts) {
+        return this.requestAPIList(Page2, { method: "get", path: path46, ...opts });
       }
       requestAPIList(Page2, options) {
         const request = this.makeRequest(options, null, void 0);
@@ -24977,8 +24977,8 @@ var init_client = __esm({
       }
       async buildRequest(inputOptions, { retryCount = 0 } = {}) {
         const options = { ...inputOptions };
-        const { method, path: path45, query, defaultBaseURL } = options;
-        const url = this.buildURL(path45, query, defaultBaseURL);
+        const { method, path: path46, query, defaultBaseURL } = options;
+        const url = this.buildURL(path46, query, defaultBaseURL);
         if ("timeout" in options)
           validatePositiveInteger("timeout", options.timeout);
         options.timeout = options.timeout ?? this.timeout;
@@ -27405,7 +27405,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@semiont/cli",
-      version: "0.3.0",
+      version: "0.3.1",
       description: "Semiont CLI - Unified environment management tool",
       _comment: "AWS SDK dependencies (@aws-sdk/*) are only used by platforms/aws",
       type: "module",
@@ -27469,12 +27469,12 @@ var require_package = __commonJS({
         "@aws-sdk/client-secrets-manager": "^3.600.0",
         "@aws-sdk/client-sts": "^3.859.0",
         "@aws-sdk/client-wafv2": "^3.859.0",
-        "@semiont/api-client": "^0.3.0",
-        "@semiont/content": "^0.3.0",
-        "@semiont/core": "^0.3.0",
-        "@semiont/event-sourcing": "^0.3.0",
-        "@semiont/graph": "^0.3.0",
-        "@semiont/make-meaning": "^0.3.0",
+        "@semiont/api-client": "^0.3.1",
+        "@semiont/content": "^0.3.1",
+        "@semiont/core": "^0.3.1",
+        "@semiont/event-sourcing": "^0.3.1",
+        "@semiont/graph": "^0.3.1",
+        "@semiont/make-meaning": "^0.3.1",
         arg: "^5.0.2",
         argon2: "^0.43.0",
         express: "^4.18.2",
@@ -29433,6 +29433,347 @@ var importCmd = new CommandBuilder().name("import").description("Import resource
   }
 }).schema(ImportOptionsSchema).handler(runImport).build();
 
+// src/core/commands/local.ts
+init_zod();
+init_cli_colors();
+init_command_definition();
+init_base_options_schema();
+import * as fs52 from "fs";
+import * as path42 from "path";
+import * as readline from "readline";
+import { execFileSync as execFileSync44 } from "child_process";
+var LocalOptionsSchema = BaseOptionsSchema.extend({
+  email: external_exports.string().optional(),
+  password: external_exports.string().optional(),
+  generatePassword: external_exports.boolean().default(true)
+}).transform((data) => ({
+  ...data,
+  environment: data.environment || "_local_"
+}));
+function prompt(question) {
+  return new Promise((resolve9) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve9(answer.trim());
+    });
+  });
+}
+function promptPassword(question) {
+  return new Promise((resolve9) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    process.stdout.write(question);
+    let password = "";
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const onData = (ch) => {
+      if (ch === "\n" || ch === "\r" || ch === "") {
+        process.stdin.setRawMode?.(false);
+        process.stdin.pause();
+        process.stdin.removeListener("data", onData);
+        process.stdout.write("\n");
+        rl.close();
+        resolve9(password);
+      } else if (ch === "\x7F") {
+        password = password.slice(0, -1);
+      } else {
+        password += ch;
+        process.stdout.write("*");
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+function runSemiont(args, env, captureOutput = false) {
+  return execFileSync44("semiont", args, {
+    env,
+    stdio: captureOutput ? "pipe" : "inherit",
+    encoding: "utf8"
+  });
+}
+function runSemiontSafe(args, env) {
+  try {
+    const output = execFileSync44("semiont", args, {
+      env,
+      stdio: "pipe",
+      encoding: "utf8"
+    });
+    return { success: true, output: output || "", error: "" };
+  } catch (err) {
+    return {
+      success: false,
+      output: err.stdout || "",
+      error: err.stderr || err.message || ""
+    };
+  }
+}
+var REQUIRED_SERVICES = ["database", "filesystem", "backend", "frontend", "proxy"];
+var EXTERNAL_SERVICES = ["graph", "inference"];
+var ALL_SERVICES = [...REQUIRED_SERVICES, ...EXTERNAL_SERVICES];
+function parseCheckOutput(jsonOutput) {
+  try {
+    const parsed = JSON.parse(jsonOutput);
+    const results = [];
+    const items = parsed.results || [];
+    for (const item of items) {
+      const name = item.entity || "";
+      const meta = item.metadata || {};
+      const statusStr = meta.status || "unknown";
+      const health = meta.health;
+      const healthy = item.success && (health?.healthy ?? statusStr === "running");
+      const status = statusStr === "running" && healthy ? "healthy" : statusStr === "running" ? "unhealthy" : statusStr === "stopped" ? "stopped" : "unknown";
+      results.push({
+        name,
+        status,
+        healthy,
+        external: EXTERNAL_SERVICES.includes(name)
+      });
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function isProvisioned(serviceName, semiotRoot) {
+  switch (serviceName) {
+    case "backend":
+      return fs52.existsSync(path42.join(semiotRoot, "backend", ".env"));
+    case "frontend":
+      return fs52.existsSync(path42.join(semiotRoot, "frontend", ".env"));
+    case "filesystem":
+      return fs52.existsSync(path42.join(semiotRoot, "data"));
+    case "database":
+    case "proxy":
+    // For these, rely on check result only — we don't have a simple local sentinel
+    default:
+      return false;
+  }
+}
+async function local(options) {
+  const startTime = Date.now();
+  const envVarsToAdvise = [];
+  const warnings = [];
+  const results = {
+    command: "local",
+    environment: "local",
+    timestamp: /* @__PURE__ */ new Date(),
+    duration: 0,
+    results: [],
+    summary: { total: 0, succeeded: 0, failed: 0, warnings: 0 },
+    executionContext: {
+      user: process.env.USER || "unknown",
+      workingDirectory: process.cwd(),
+      dryRun: false
+    }
+  };
+  console.log(`
+${colors.bright}\u{1F310} Semiont Local Setup${colors.reset}
+`);
+  try {
+    let semiotRoot = process.env.SEMIONT_ROOT || "";
+    if (!semiotRoot) {
+      const defaultPath = path42.join(process.env.HOME || process.cwd(), "semiont");
+      const answer = await prompt(
+        `${colors.cyan}SEMIONT_ROOT is not set.${colors.reset}
+Press Enter to use ${colors.bright}${defaultPath}${colors.reset}, or type a path: `
+      );
+      semiotRoot = answer || defaultPath;
+      fs52.mkdirSync(semiotRoot, { recursive: true });
+      process.env.SEMIONT_ROOT = semiotRoot;
+      envVarsToAdvise.push(`export SEMIONT_ROOT=${semiotRoot}`);
+      console.log(`${colors.green}\u2713${colors.reset} Using ${semiotRoot}
+`);
+    } else {
+      console.log(`${colors.green}\u2713${colors.reset} SEMIONT_ROOT=${semiotRoot}
+`);
+    }
+    let semiotEnv = process.env.SEMIONT_ENV || "";
+    if (!semiotEnv) {
+      semiotEnv = "local";
+      process.env.SEMIONT_ENV = semiotEnv;
+      envVarsToAdvise.push(`export SEMIONT_ENV=local`);
+      console.log(`${colors.dim}SEMIONT_ENV not set, using "local"${colors.reset}
+`);
+    } else {
+      console.log(`${colors.green}\u2713${colors.reset} SEMIONT_ENV=${semiotEnv}
+`);
+    }
+    const env = { ...process.env };
+    const semiontJsonPath = path42.join(semiotRoot, "semiont.json");
+    const envFilePath = path42.join(semiotRoot, "environments", `${semiotEnv}.json`);
+    const isInitialized = fs52.existsSync(semiontJsonPath) && fs52.existsSync(envFilePath);
+    if (isInitialized) {
+      console.log(`${colors.green}\u2713${colors.reset} Project already initialized
+`);
+    } else {
+      console.log(`${colors.cyan}\u25B6 Initializing project...${colors.reset}`);
+      try {
+        runSemiont(["init"], env);
+        console.log(`${colors.green}\u2713${colors.reset} Project initialized
+`);
+      } catch {
+        console.error(`${colors.red}\u2717 semiont init failed \u2014 cannot continue${colors.reset}`);
+        results.summary.failed = 1;
+        results.duration = Date.now() - startTime;
+        return results;
+      }
+    }
+    console.log(`${colors.cyan}\u25B6 Checking services...${colors.reset}`);
+    const checkResult = runSemiontSafe(["check", "--all", "--output", "json"], env);
+    const serviceStatuses = parseCheckOutput(checkResult.output);
+    const statusByName = new Map(
+      serviceStatuses.map((s) => [s.name, s])
+    );
+    for (const serviceName of ALL_SERVICES) {
+      const info = statusByName.get(serviceName);
+      const isExternal = EXTERNAL_SERVICES.includes(serviceName);
+      if (!info) {
+        if (isExternal) {
+          warnings.push(`${serviceName}: not found in check output (external \u2014 skipping)`);
+          console.log(`  ${colors.yellow}\u26A0 ${serviceName}${colors.reset} (external): not found in check output`);
+          continue;
+        }
+        console.log(`  ${colors.yellow}? ${serviceName}${colors.reset}: not found \u2014 provisioning...`);
+      } else if (info.healthy) {
+        console.log(`  ${colors.green}\u2713 ${serviceName}${colors.reset}: running`);
+        continue;
+      } else if (isExternal && !info.healthy) {
+        warnings.push(`${serviceName}: unhealthy (external service \u2014 check credentials)`);
+        console.log(`  ${colors.yellow}\u26A0 ${serviceName}${colors.reset} (external): unhealthy \u2014 check your credentials`);
+        continue;
+      }
+      const alreadyProvisioned = info ? info.status === "stopped" && isProvisioned(serviceName, semiotRoot) : false;
+      if (!alreadyProvisioned) {
+        console.log(`  ${colors.cyan}  provisioning ${serviceName}...${colors.reset}`);
+        const provResult = runSemiontSafe(["provision", "--service", serviceName], env);
+        if (!provResult.success) {
+          const combinedOutput = provResult.error + provResult.output;
+          if (combinedOutput.includes("does not support capability 'provision'")) {
+          } else {
+            const msg = `Failed to provision ${serviceName}: ${provResult.error}`;
+            if (isExternal) {
+              warnings.push(msg);
+              console.log(`  ${colors.yellow}  \u26A0 ${msg}${colors.reset}`);
+              continue;
+            } else {
+              throw new Error(msg);
+            }
+          }
+        }
+      }
+      console.log(`  ${colors.cyan}  starting ${serviceName}...${colors.reset}`);
+      const startResult = runSemiontSafe(["start", "--service", serviceName], env);
+      if (!startResult.success) {
+        const combinedOutput = startResult.error + startResult.output;
+        if (combinedOutput.includes("does not support capability 'start'")) {
+        } else {
+          const msg = `Failed to start ${serviceName}: ${startResult.error}`;
+          if (isExternal) {
+            warnings.push(msg);
+            console.log(`  ${colors.yellow}  \u26A0 ${msg}${colors.reset}`);
+          } else {
+            throw new Error(msg);
+          }
+        }
+      } else {
+        console.log(`  ${colors.green}  \u2713 ${serviceName} started${colors.reset}`);
+      }
+    }
+    console.log("");
+    const credentialsPath = path42.join(semiotRoot, "credentials.txt");
+    if (fs52.existsSync(credentialsPath)) {
+      console.log(`${colors.green}\u2713${colors.reset} Credentials file already exists at ${credentialsPath}
+`);
+    } else {
+      console.log(`${colors.cyan}\u25B6 Creating admin user...${colors.reset}`);
+      let email = options.email;
+      if (!email) {
+        const answer = await prompt(`  Admin email [admin@local]: `);
+        email = answer || "admin@local";
+      }
+      let generatePassword2 = options.generatePassword;
+      if (!options.password) {
+        const answer = await prompt(`  Generate password? [Y/n]: `);
+        generatePassword2 = answer === "" || answer.toLowerCase() === "y";
+      }
+      const useraddArgs = ["useradd", "--email", email, "--admin"];
+      if (generatePassword2) {
+        useraddArgs.push("--generate-password");
+      } else {
+        const pw = options.password || await promptPassword(`  Password: `);
+        useraddArgs.push("--password", pw);
+      }
+      const useraddResult = runSemiontSafe(useraddArgs, env);
+      if (useraddResult.success) {
+        const output = useraddResult.output;
+        console.log(output);
+        fs52.writeFileSync(credentialsPath, output, { mode: 384 });
+        console.log(`${colors.green}\u2713${colors.reset} Credentials saved to ${credentialsPath}`);
+        console.log(`${colors.yellow}  \u26A0 credentials.txt contains a plaintext password \u2014 keep it safe${colors.reset}
+`);
+      } else {
+        console.log(`${colors.yellow}\u26A0 useradd failed: ${useraddResult.error}${colors.reset}`);
+        console.log(`  Run manually: semiont useradd --email <email> --generate-password --admin
+`);
+        warnings.push(`useradd failed: ${useraddResult.error}`);
+      }
+    }
+    console.log(`${colors.cyan}\u25B6 Final service check...${colors.reset}
+`);
+    runSemiont(["check", "--all"], env);
+    console.log(`
+${colors.bright}${colors.green}\u2713 Semiont is running at http://localhost:8080${colors.reset}
+`);
+    console.log(`  Credentials: ${credentialsPath}`);
+    if (warnings.length > 0) {
+      console.log(`
+${colors.yellow}Warnings:${colors.reset}`);
+      for (const w of warnings) {
+        console.log(`  ${colors.yellow}\u26A0${colors.reset} ${w}`);
+      }
+    }
+    if (envVarsToAdvise.length > 0) {
+      console.log(`
+To persist your environment across sessions, add to your shell profile:`);
+      for (const line of envVarsToAdvise) {
+        console.log(`  ${colors.cyan}${line}${colors.reset}`);
+      }
+    }
+    results.summary.succeeded = 1;
+    results.metadata = { semiotRoot, semiotEnv, credentialsPath };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`
+${colors.red}\u2717 Setup failed: ${msg}${colors.reset}`);
+    results.summary.failed = 1;
+    results.error = msg;
+  }
+  results.duration = Date.now() - startTime;
+  return results;
+}
+var localCommand = new CommandBuilder().name("local").description("Set up and start Semiont locally (init + provision + start + useradd)").schema(LocalOptionsSchema).args(withBaseArgs({
+  "--email": {
+    type: "string",
+    description: "Admin user email (default: admin@local)"
+  },
+  "--password": {
+    type: "string",
+    description: "Admin user password (default: auto-generate)"
+  },
+  "--generate-password": {
+    type: "boolean",
+    description: "Generate a random admin password",
+    default: true
+  }
+}, {
+  "--email": "--email"
+})).requiresEnvironment(false).requiresServices(false).examples(
+  "semiont local",
+  "semiont local --email me@example.com",
+  "semiont local --email me@example.com --generate-password"
+).setupHandler(local).build();
+
 // src/core/command-discovery.ts
 var commandCache = /* @__PURE__ */ new Map();
 var COMMANDS = {
@@ -29449,7 +29790,8 @@ var COMMANDS = {
   "restore": restoreCmd,
   "verify": verifyCmd,
   "export": exportCmd,
-  "import": importCmd
+  "import": importCmd,
+  "local": localCommand
 };
 async function loadCommand(name) {
   if (commandCache.has(name)) {
@@ -29495,8 +29837,8 @@ function isCommandDefinition(obj) {
 
 // src/core/service-discovery.ts
 init_config_loader();
-import * as path42 from "path";
-import * as fs52 from "fs";
+import * as path43 from "path";
+import * as fs53 from "fs";
 var BUILT_IN_SERVICES = ["frontend", "backend", "database", "filesystem"];
 var environmentServicesCache = /* @__PURE__ */ new Map();
 async function loadEnvironmentServices(environment) {
@@ -29505,11 +29847,11 @@ async function loadEnvironmentServices(environment) {
   }
   try {
     const PROJECT_ROOT = findProjectRoot();
-    const configPath = path42.join(PROJECT_ROOT, "environments", `${environment}.json`);
-    if (!fs52.existsSync(configPath)) {
+    const configPath = path43.join(PROJECT_ROOT, "environments", `${environment}.json`);
+    if (!fs53.existsSync(configPath)) {
       return [...BUILT_IN_SERVICES];
     }
-    const jsonContent = fs52.readFileSync(configPath, "utf-8");
+    const jsonContent = fs53.readFileSync(configPath, "utf-8");
     const config = JSON.parse(jsonContent);
     const services = config.services ? Object.keys(config.services) : [];
     environmentServicesCache.set(environment, services);
@@ -29540,7 +29882,7 @@ async function isValidService(service, environment) {
 import { parseEnvironment as parseEnvironment2 } from "@semiont/core";
 
 // src/core/service-resolver.ts
-import * as path43 from "path";
+import * as path44 from "path";
 import { ConfigurationError as ConfigurationError2 } from "@semiont/core";
 function getServicePlatform(serviceName, config) {
   const environment = config._metadata?.environment;
@@ -29588,7 +29930,7 @@ function resolveServiceDeployments(serviceNames, config) {
     const serviceConfig = config.services?.[serviceName];
     if (!serviceConfig) {
       const availableServices = Object.keys(config.services || {});
-      const configPath = path43.join(projectRoot, "environments", `${environment}.json`);
+      const configPath = path44.join(projectRoot, "environments", `${environment}.json`);
       console.warn(`\u274C Service '${serviceName}' not found in environment '${environment}'`);
       if (availableServices.length > 0) {
         console.warn(`   Available services: ${availableServices.join(", ")}`);
@@ -29627,7 +29969,7 @@ function resolveServiceDeployments(serviceNames, config) {
 // src/core/command-service-matcher.ts
 init_service_factory();
 init_service_command_capabilities();
-import * as path44 from "path";
+import * as path45 from "path";
 async function checkServiceSupportsCommand(serviceName, command, envConfig) {
   try {
     const projectRoot = envConfig._metadata?.projectRoot;
@@ -29711,7 +30053,7 @@ async function resolveServiceSelector(selector, capability, envConfig) {
     if (!projectRoot) {
       throw new Error("Project root is required in envConfig._metadata");
     }
-    const configPath = path44.join(projectRoot, "environments", `${environment}.json`);
+    const configPath = path45.join(projectRoot, "environments", `${environment}.json`);
     const errorMessage = [
       `Unknown service '${selector}' in environment '${environment}'`,
       `Available services: ${availableServices.join(", ")}`,
@@ -30207,14 +30549,14 @@ var OutputFormatter = class {
   /**
    * Get nested value from object using dot notation
    */
-  static getNestedValue(obj, path45) {
-    return path45.split(".").reduce((current, key) => current?.[key], obj);
+  static getNestedValue(obj, path46) {
+    return path46.split(".").reduce((current, key) => current?.[key], obj);
   }
   /**
    * Set nested value in object using dot notation
    */
-  static setNestedValue(obj, path45, value) {
-    const keys = path45.split(".");
+  static setNestedValue(obj, path46, value) {
+    const keys = path46.split(".");
     const lastKey = keys.pop();
     const target = keys.reduce((current, key) => {
       if (!(key in current)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semiont/cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Semiont CLI - Unified environment management tool",
   "_comment": "AWS SDK dependencies (@aws-sdk/*) are only used by platforms/aws",
   "type": "module",
@@ -64,12 +64,12 @@
     "@aws-sdk/client-secrets-manager": "^3.600.0",
     "@aws-sdk/client-sts": "^3.859.0",
     "@aws-sdk/client-wafv2": "^3.859.0",
-    "@semiont/api-client": "0.3.0",
-    "@semiont/content": "0.3.0",
-    "@semiont/core": "0.3.0",
-    "@semiont/event-sourcing": "0.3.0",
-    "@semiont/graph": "0.3.0",
-    "@semiont/make-meaning": "0.3.0",
+    "@semiont/api-client": "0.3.1",
+    "@semiont/content": "0.3.1",
+    "@semiont/core": "0.3.1",
+    "@semiont/event-sourcing": "0.3.1",
+    "@semiont/graph": "0.3.1",
+    "@semiont/make-meaning": "0.3.1",
     "arg": "^5.0.2",
     "argon2": "^0.43.0",
     "express": "^4.18.2",