@odeva/cli 0.0.4 → 0.0.6

package/dist/commands/app/config/link.js

@@ -3,9 +3,11 @@ import * as p from "@clack/prompts";
 import { OdevaApi } from "../../../lib/api.js";
 import { loadAppConfig, saveAppConfig, ADMIN_ICONS } from "../../../lib/config.js";
 import { saveAppEnv } from "../../../lib/app-env.js";
+import { loadCredentials } from "../../../lib/credentials.js";
 import { withErrorHandling } from "../../../lib/run.js";
 import { ui } from "../../../lib/ui.js";
-import { CliError } from "../../../lib/errors.js";
+import { ApiError, CliError } from "../../../lib/errors.js";
+import { isValidSlug } from "../../../lib/slug.js";
 function buildAdminEmbedInput(admin, configPath) {
   const validIcons = ADMIN_ICONS;
   if (!validIcons.includes(admin.sidebar.icon)) {
@@ -63,29 +65,18 @@ class AppConfigLink extends Command {
         if (match) existingId = match.id;
       }
       spinner.message(existingId ? "Updating app on Odeva" : "Creating app on Odeva");
-      const { app, rawClientSecret } = await api.upsertDeveloperApp({
-        id: existingId,
-        name: loaded.config.name,
-        slug: loaded.config.slug,
-        description: loaded.config.description,
-        homepageUrl: loaded.config.homepage_url,
-        installUrl: loaded.config.install_url,
-        privacyUrl: loaded.config.privacy_url,
-        requestedScopes: loaded.config.access_scopes?.scopes,
-        // `webhookUrl` is the install-time URL recorded on the App; per-event
-        // subscriptions are managed separately by `odeva app dev` against the
-        // tunnel URL.
-        ...adminInput ? { adminEmbed: adminInput } : {}
-      });
+      const { app, rawClientSecret } = await upsertWithSlugRetry(api, spinner, loaded, existingId, adminInput);
       spinner.stop(`${existingId ? "Updated" : "Registered"} app ${ui.code(app.slug)} (client_id ${ui.code(app.clientId)})`);
       loaded.config.client_id = app.clientId;
       saveAppConfig(loaded);
-      let envPath = null;
+      const creds = loadCredentials();
+      const envValues = {
+        ODEVA_APP_CLIENT_ID: app.clientId,
+        ...rawClientSecret ? { ODEVA_APP_CLIENT_SECRET: rawClientSecret } : {},
+        ...creds?.organizationSlug ? { ODEVA_ORGANIZATION_SLUG: creds.organizationSlug } : {}
+      };
+      const envPath = saveAppEnv(loaded.path, envValues);
       if (rawClientSecret) {
-        envPath = saveAppEnv(loaded.path, {
-          ODEVA_APP_CLIENT_ID: app.clientId,
-          ODEVA_APP_CLIENT_SECRET: rawClientSecret
-        });
         p.note(
           [
             "This is the only time the secret is shown.",
@@ -101,7 +92,8 @@ class AppConfigLink extends Command {
       p.outro(
         [
           ui.ok(`Wrote client_id to ${ui.code(loaded.path)}`),
-          envPath ? ui.ok(`Wrote client_secret to ${ui.code(envPath)}`) : null,
+          rawClientSecret ? ui.ok(`Wrote client_secret to ${ui.code(envPath)}`) : null,
+          creds?.organizationSlug ? ui.ok(`Wrote organization slug to ${ui.code(envPath)}`) : null,
           "",
           `  Next: ${ui.code("odeva app dev")} to run the app locally with a public tunnel.`
         ].filter((line) => line !== null).join("\n")
@@ -109,6 +101,50 @@ class AppConfigLink extends Command {
     });
   }
 }
+const SLUG_TAKEN_RE = /slug.*(?:already been taken|taken|in use|exists)/i;
+async function upsertWithSlugRetry(api, spinner, loaded, existingId, adminInput) {
+  for (; ; ) {
+    try {
+      return await api.upsertDeveloperApp({
+        id: existingId,
+        name: loaded.config.name,
+        slug: loaded.config.slug,
+        description: loaded.config.description,
+        homepageUrl: loaded.config.homepage_url,
+        installUrl: loaded.config.install_url,
+        privacyUrl: loaded.config.privacy_url,
+        requestedScopes: loaded.config.access_scopes?.scopes,
+        ...adminInput ? { adminEmbed: adminInput } : {}
+      });
+    } catch (err) {
+      if (!(err instanceof ApiError) || !SLUG_TAKEN_RE.test(err.message)) throw err;
+      spinner.stop(ui.warn(`Slug '${loaded.config.slug}' is already taken.`));
+      const creds = loadCredentials();
+      const suggestion = creds?.organizationSlug && !loaded.config.slug.startsWith(`${creds.organizationSlug}-`) ? `${creds.organizationSlug}-${loaded.config.slug}` : `${loaded.config.slug}-2`;
+      const next = await p.text({
+        message: "Pick a new slug",
+        placeholder: suggestion,
+        initialValue: suggestion,
+        validate: (v) => {
+          const trimmed = v.trim();
+          if (!isValidSlug(trimmed)) {
+            return "Slugs are lowercase letters, digits, and hyphens (e.g. 'cabin-manager').";
+          }
+          if (trimmed === loaded.config.slug) {
+            return "Pick a different slug than the one that's taken.";
+          }
+          return void 0;
+        }
+      });
+      if (p.isCancel(next)) {
+        throw new CliError("link cancelled.");
+      }
+      loaded.config.slug = next.trim();
+      saveAppConfig(loaded);
+      spinner.start(existingId ? "Updating app on Odeva" : "Creating app on Odeva");
+    }
+  }
+}
 export {
   buildAdminEmbedInput,
   AppConfigLink as default

package/dist/commands/app/dev.js

@@ -5,6 +5,8 @@ import { OdevaApi } from "../../lib/api.js";
 import { loadAppConfig } from "../../lib/config.js";
 import { loadAppEnv } from "../../lib/app-env.js";
 import { startQuickTunnel } from "../../lib/cloudflared.js";
+import { loadCredentials } from "../../lib/credentials.js";
+import { adminUrl } from "../../lib/paths.js";
 import {
   cleanupSubscriptions,
   preflightChecks,
@@ -64,6 +66,7 @@ class AppDev extends Command {
         this.log(`  ${ui.dim("\u2192")} ${reg.config.topic.padEnd(28)} ${reg.fullUrl}`);
       }
       this.log("");
+      this.printInstallHint(loaded, tunnel.url);
       this.log(ui.dim("Press Ctrl-C to stop. Subscriptions will be cleaned up on exit."));
       this.log("");
       let server = spawnDevServer({
@@ -142,6 +145,26 @@ class AppDev extends Command {
       await Promise.allSettled([tunnel.stop(), cleanupSubscriptions(api, registered)]);
     });
   }
+  printInstallHint(loaded, tunnelUrl) {
+    const creds = loadCredentials();
+    const apps = adminUrl(creds?.apiUrl);
+    this.log(`${ui.bold("Install:")}    ${apps}/settings/apps  ${ui.dim('(find your draft app under "Your apps")')}`);
+    if (creds?.organizationSlug) {
+      this.log(`  ${ui.dim("org:")}      ${creds.organizationSlug}`);
+    }
+    const installUrl = loaded.config.install_url?.trim();
+    const expected = `${tunnelUrl}/install`;
+    if (!installUrl) {
+      this.log(ui.warn(
+        `install_url in odeva.app.toml is empty \u2014 installs won't redirect back. Set it to ${expected} and re-run \`odeva app config link\` (or use a stable URL once you deploy).`
+      ));
+    } else if (!installUrl.startsWith(tunnelUrl) && !/localhost|127\.0\.0\.1/.test(installUrl)) {
+      this.log(ui.warn(
+        `install_url is ${installUrl} \u2014 installs from your org will redirect there, not to this tunnel. Update odeva.app.toml + \`odeva app config link\` if you want installs to hit the dev tunnel.`
+      ));
+    }
+    this.log("");
+  }
   async registerDevWebhooks(api, loaded, tunnelUrl) {
     const subscriptions = loaded.config.webhooks?.subscriptions ?? [];
     if (subscriptions.length === 0) {

package/dist/commands/app/init.js

@@ -2,11 +2,14 @@ import { Args, Command, Flags } from "@oclif/core";
 import * as p from "@clack/prompts";
 import { existsSync } from "node:fs";
 import { basename, resolve } from "node:path";
+import { OdevaApi } from "../../lib/api.js";
+import { loadCredentials } from "../../lib/credentials.js";
 import { CliError } from "../../lib/errors.js";
 import { withErrorHandling } from "../../lib/run.js";
 import { isValidSlug, slugify } from "../../lib/slug.js";
 import { listTemplates, renderTemplate } from "../../lib/templates.js";
 import { ui } from "../../lib/ui.js";
+import { detectShell, isCompletionInstalled } from "../autocomplete.js";
 const DEFAULT_TEMPLATE = "hono-bun";
 class AppInit extends Command {
   static description = "Scaffold a new Odeva app";
@@ -43,8 +46,12 @@ class AppInit extends Command {
     await withErrorHandling(this, async () => {
       p.intro(ui.brand("odeva app init"));
       const directory = await this.resolveDirectory(args.name, flags.yes);
-      const slug = this.resolveSlug(flags.slug ?? slugify(basename(directory)));
       const displayName = flags["display-name"] ?? toTitleCase(basename(directory));
+      const slug = await this.resolveSlug({
+        explicit: flags.slug,
+        dirBase: basename(directory),
+        skipPrompts: flags.yes
+      });
       const template = flags.template;
       if (!listTemplates().includes(template)) {
         throw new CliError(`Unknown template: '${template}'.`, {
@@ -62,17 +69,23 @@ class AppInit extends Command {
         }
       });
       spinner.stop(`Wrote ${filesWritten} file${filesWritten === 1 ? "" : "s"} from template '${template}'.`);
-      p.outro(
-        [
-          ui.ok(`Created ${ui.bold(displayName)}`),
+      const outroLines = [
+        ui.ok(`Created ${ui.bold(displayName)}`),
+        "",
+        "  Next steps:",
+        `    ${ui.code(`cd ${basename(directory)}`)}`,
+        `    ${ui.code("bun install")}`,
+        `    ${ui.code("odeva app config link")}    ${ui.dim("# register on Odeva")}`,
+        `    ${ui.code("odeva app dev")}             ${ui.dim("# start local dev with a tunnel")}`
+      ];
+      const shell = detectShell();
+      if (shell && !isCompletionInstalled(shell, "odeva")) {
+        outroLines.push(
           "",
-          "  Next steps:",
-          `    ${ui.code(`cd ${basename(directory)}`)}`,
-          `    ${ui.code("bun install")}`,
-          `    ${ui.code("odeva app config link")}    ${ui.dim("# register on Odeva")}`,
-          `    ${ui.code("odeva app dev")}             ${ui.dim("# start local dev with a tunnel")}`
-        ].join("\n")
-      );
+          `  ${ui.dim("Tip:")} ${ui.code("odeva autocomplete --install")} ${ui.dim("to enable tab-completion.")}`
+        );
+      }
+      p.outro(outroLines.join("\n"));
     });
   }
   async resolveDirectory(nameArg, skipPrompts) {
@@ -106,14 +119,63 @@ class AppInit extends Command {
     }
     return directory;
   }
-  resolveSlug(candidate) {
-    const slug = candidate.trim();
-    if (!isValidSlug(slug)) {
-      throw new CliError(`Invalid slug '${slug}'.`, {
-        hint: "Slugs are lowercase letters, digits, and hyphens (e.g. 'cabin-manager')."
+  async resolveSlug(opts) {
+    const creds = loadCredentials();
+    const orgSlug = creds?.organizationSlug;
+    const derived = slugify(opts.dirBase);
+    const initial = opts.explicit?.trim() || (orgSlug ? `${orgSlug}-${derived}` : derived);
+    validateSlug(initial);
+    if (opts.explicit || opts.skipPrompts || !creds) {
+      if (creds && opts.explicit) await assertAvailable(initial);
+      return initial;
+    }
+    let candidate = initial;
+    const api = new OdevaApi({ credentials: creds });
+    for (; ; ) {
+      const available = await isAvailable(api, candidate);
+      if (available !== false) return candidate;
+      const next = await p.text({
+        message: `Slug '${candidate}' is already taken \u2014 pick another`,
+        placeholder: `${candidate}-2`,
+        initialValue: `${candidate}-2`,
+        validate: (v) => {
+          const trimmed = v.trim();
+          if (!isValidSlug(trimmed)) {
+            return "Slugs are lowercase letters, digits, and hyphens (e.g. 'cabin-manager').";
+          }
+          return void 0;
+        }
       });
+      if (p.isCancel(next)) {
+        throw new CliError("init cancelled.");
+      }
+      candidate = next.trim();
     }
-    return slug;
+  }
+}
+function validateSlug(slug) {
+  if (!isValidSlug(slug)) {
+    throw new CliError(`Invalid slug '${slug}'.`, {
+      hint: "Slugs are lowercase letters, digits, and hyphens (e.g. 'cabin-manager')."
+    });
+  }
+}
+async function isAvailable(api, slug) {
+  try {
+    return await api.developerAppSlugAvailable(slug);
+  } catch {
+    return null;
+  }
+}
+async function assertAvailable(slug) {
+  const creds = loadCredentials();
+  if (!creds) return;
+  const api = new OdevaApi({ credentials: creds });
+  const ok = await isAvailable(api, slug);
+  if (ok === false) {
+    throw new CliError(`Slug '${slug}' is already taken.`, {
+      hint: "Choose another with --slug, or omit --slug to be prompted."
+    });
   }
 }
 function toTitleCase(input) {

package/dist/commands/autocomplete.js

@@ -0,0 +1,215 @@
+import { Args, Command, Flags } from "@oclif/core";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { CliError } from "../lib/errors.js";
+import { withErrorHandling } from "../lib/run.js";
+import { ui } from "../lib/ui.js";
+const SUPPORTED_SHELLS = ["fish", "zsh"];
+class Autocomplete extends Command {
+  static description = "Print or install a shell completion script for the odeva CLI";
+  static examples = [
+    "$ odeva autocomplete --install                                  # detect shell and install",
+    "$ odeva autocomplete fish --install                             # explicit shell",
+    "$ odeva autocomplete fish > ~/.config/fish/completions/odeva.fish"
+  ];
+  static args = {
+    shell: Args.string({
+      description: "Target shell (auto-detected from $SHELL when omitted with --install)",
+      options: [...SUPPORTED_SHELLS],
+      required: false
+    })
+  };
+  static flags = {
+    install: Flags.boolean({
+      description: "Write the completion script to the conventional path for the shell",
+      default: false
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(Autocomplete);
+    await withErrorHandling(this, async () => {
+      const bin = this.config.bin;
+      const shell = args.shell ?? (flags.install ? detectShell() : void 0);
+      if (!shell) {
+        if (flags.install) {
+          throw new CliError("Couldn't detect shell from $SHELL.", {
+            hint: `Pass it explicitly: \`${bin} autocomplete <${SUPPORTED_SHELLS.join("|")}> --install\`.`
+          });
+        }
+        throw new CliError("A shell is required.", {
+          hint: `Usage: \`${bin} autocomplete <${SUPPORTED_SHELLS.join("|")}>\`. Add --install to write the script to the conventional path.`
+        });
+      }
+      const tree = buildCommandTree(this.config.commands, bin);
+      const script = shell === "fish" ? renderFish(bin, tree) : renderZsh(bin, tree);
+      if (!flags.install) {
+        process.stdout.write(script);
+        return;
+      }
+      const target = completionInstallPath(shell, bin);
+      mkdirSync(dirname(target), { recursive: true });
+      writeFileSync(target, script, { mode: 420 });
+      this.log(ui.ok(`Wrote ${shell} completion to ${ui.code(target)}`));
+      if (shell === "fish") {
+        this.log(ui.dim("  Open a new fish shell \u2014 completions auto-load from this path."));
+      } else {
+        const fpathDir = dirname(target);
+        this.log("");
+        this.log("  Add this to your ~/.zshrc (if you haven't already):");
+        this.log("");
+        this.log(ui.code(`    fpath=(${fpathDir} $fpath)`));
+        this.log(ui.code(`    autoload -U compinit && compinit`));
+        this.log("");
+        this.log(ui.dim("  Then open a new zsh shell."));
+      }
+    });
+  }
+}
+function detectShell(env = process.env) {
+  const shell = env["SHELL"];
+  if (!shell) return null;
+  const name = basename(shell);
+  if (name === "fish" || name === "zsh") return name;
+  return null;
+}
+function completionInstallPath(shell, bin, env = process.env) {
+  const home = env["HOME"] || homedir();
+  if (shell === "fish") {
+    const config = env["XDG_CONFIG_HOME"] || join(home, ".config");
+    return join(config, "fish", "completions", `${bin}.fish`);
+  }
+  const data = env["XDG_DATA_HOME"] || join(home, ".local", "share");
+  return join(data, bin, "completions", `_${bin}`);
+}
+function isCompletionInstalled(shell, bin, env = process.env) {
+  return existsSync(completionInstallPath(shell, bin, env));
+}
+function buildCommandTree(commands, binName) {
+  const root = { name: "", description: "", children: /* @__PURE__ */ new Map() };
+  for (const cmd of commands) {
+    if (cmd.hidden || cmd.id === "autocomplete") continue;
+    const segments = cmd.id.split(":");
+    let node = root;
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      const isLeaf = i === segments.length - 1;
+      let child = node.children.get(seg);
+      if (!child) {
+        child = { name: seg, description: "", children: /* @__PURE__ */ new Map() };
+        node.children.set(seg, child);
+      }
+      if (isLeaf) {
+        child.command = cmd;
+        const rawDesc = cmd.summary || cmd.description?.split("\n")[0] || "";
+        child.description = rawDesc.replace(/<%=\s*config\.bin\s*%>/g, binName);
+      }
+      node = child;
+    }
+  }
+  return root;
+}
+function shellSingleQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function renderFish(bin, root) {
+  const lines = [
+    `# fish completion for ${bin}`,
+    `# Generated by \`${bin} autocomplete fish\``,
+    "",
+    `function __${bin}_at_path`,
+    "    # Returns 0 if the current command line is exactly `bin arg1 arg2 ...`",
+    "    set -l tokens (commandline -opc)",
+    "    set -e tokens[1]",
+    "    test (count $tokens) -eq (count $argv); or return 1",
+    "    for i in (seq (count $argv))",
+    '        test "$tokens[$i]" = "$argv[$i]"; or return 1',
+    "    end",
+    "    return 0",
+    "end",
+    ""
+  ];
+  const walk = (node, path) => {
+    if (node.children.size > 0) {
+      const condition = path.length === 0 ? `__${bin}_at_path` : `__${bin}_at_path ${path.join(" ")}`;
+      for (const child of node.children.values()) {
+        const desc = child.description.replace(/\s+/g, " ").trim();
+        const descPart = desc ? ` -d ${shellSingleQuote(desc)}` : "";
+        lines.push(`complete -c ${bin} -n ${shellSingleQuote(condition)} -f -a ${shellSingleQuote(child.name)}${descPart}`);
+      }
+    }
+    if (node.command) {
+      const condition = `__${bin}_at_path ${path.join(" ")}`;
+      for (const [flagName, flag] of Object.entries(node.command.flags)) {
+        if (flag.hidden) continue;
+        const desc = (flag.summary || flag.description || "").replace(/\s+/g, " ").trim();
+        const descPart = desc ? ` -d ${shellSingleQuote(desc)}` : "";
+        const takesValue = flag.type === "option" ? " -r" : "";
+        const short = flag.char ? ` -s ${flag.char}` : "";
+        lines.push(`complete -c ${bin} -n ${shellSingleQuote(condition)} -l ${flagName}${short}${takesValue}${descPart}`);
+      }
+    }
+    for (const child of node.children.values()) {
+      walk(child, [...path, child.name]);
+    }
+  };
+  walk(root, []);
+  return lines.join("\n") + "\n";
+}
+function renderZsh(bin, root) {
+  const dispatch = [];
+  const collect = (node, path) => {
+    const key = path.join(" ");
+    const subcommands = [];
+    for (const child of node.children.values()) {
+      const desc = child.description.replace(/[:\s]+/g, " ").trim();
+      subcommands.push(`'${child.name}:${desc}'`);
+    }
+    const flagLines = [];
+    if (node.command) {
+      for (const [flagName, flag] of Object.entries(node.command.flags)) {
+        if (flag.hidden) continue;
+        const desc = (flag.summary || flag.description || "").replace(/[:[\]]/g, " ").trim();
+        const arg = flag.type === "option" ? ":value:" : "";
+        flagLines.push(`'--${flagName}[${desc}]${arg}'`);
+        if (flag.char) flagLines.push(`'-${flag.char}[${desc}]${arg}'`);
+      }
+    }
+    dispatch.push(
+      `    ${shellSingleQuote(key)})`,
+      `      _values 'subcommand or flag' ${[...subcommands, ...flagLines].join(" ")}`,
+      `      ;;`
+    );
+    for (const child of node.children.values()) {
+      collect(child, [...path, child.name]);
+    }
+  };
+  collect(root, []);
+  return `#compdef ${bin}
+# zsh completion for ${bin}
+# Generated by \`${bin} autocomplete zsh\`
+
+_${bin}() {
+  local -a words
+  words=("\${(@)words[2,$CURRENT - 1]}")
+  local key="\${(j: :)words}"
+  case "$key" in
+${dispatch.join("\n")}
+    *)
+      _values 'subcommand'
+      ;;
+  esac
+}
+
+_${bin} "$@"
+`;
+}
+export {
+  buildCommandTree,
+  completionInstallPath,
+  Autocomplete as default,
+  detectShell,
+  isCompletionInstalled,
+  renderFish,
+  renderZsh
+};

package/dist/lib/api.js

@@ -89,6 +89,21 @@ class OdevaApi {
     );
     return data.cliAuthPoll;
   }
+  /**
+   * Check whether a developer-app slug is free. Returns `null` when the CLI
+   * isn't authenticated yet (init can be invoked before `auth login`) so
+   * callers can fall back to local validation instead of bailing.
+   */
+  async developerAppSlugAvailable(slug, excludeId) {
+    if (!this.authenticated) return null;
+    const data = await this.request(
+      `query OdevaCliDeveloperAppSlugAvailable($slug: String!, $excludeId: ID) {
+        developerAppSlugAvailable(slug: $slug, excludeId: $excludeId)
+      }`,
+      { slug, excludeId }
+    );
+    return data.developerAppSlugAvailable;
+  }
   async listDeveloperApps() {
     const data = await this.request(`
       query OdevaCliListDeveloperApps {

package/dist/lib/paths.js

@@ -5,9 +5,16 @@ const CONFIG_DIR = join(xdgConfigHome, "odeva");
 const CREDENTIALS_PATH = join(CONFIG_DIR, "credentials.json");
 const APP_CONFIG_FILE = "odeva.app.toml";
 const DEFAULT_API_URL = process.env["ODEVA_API_URL"] || "https://booking.odeva.app";
+function adminUrl(apiUrl = DEFAULT_API_URL) {
+  const override = process.env["ODEVA_ADMIN_URL"];
+  if (override) return override.replace(/\/$/, "");
+  const base = apiUrl.replace(/\/$/, "");
+  return /localhost|127\.0\.0\.1/.test(base) ? base : `${base}/admin`;
+}
 export {
   APP_CONFIG_FILE,
   CONFIG_DIR,
   CREDENTIALS_PATH,
-  DEFAULT_API_URL
+  DEFAULT_API_URL,
+  adminUrl
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@odeva/cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Build apps on the Odeva booking platform — scaffold, develop, deploy.",
   "license": "MIT",
   "type": "module",