nikcli 0.0.6

package/src/cli/cmd/import.ts

@@ -0,0 +1,201 @@
+import type { Argv } from "yargs"
+import { Session } from "../../session"
+import { cmd } from "./cmd"
+import { bootstrap } from "../bootstrap"
+import { Storage } from "../../storage/storage"
+import { Instance } from "../../project/instance"
+import { EOL } from "os"
+
+const SHARE_ID = /^[a-zA-Z0-9_-]+$/
+
+function resolveEnterpriseOrigin(hostname: string) {
+  if (hostname === "nikcli.store") return "https://s.nikcli.store"
+  if (hostname === "dev.nikcli.store") return "https://dev.s.nikcli.store"
+  if (hostname.endsWith(".dev.nikcli.store")) {
+    const stage = hostname.slice(0, -".dev.nikcli.store".length)
+    if (stage) return `https://${stage}.dev.s.nikcli.store`
+  }
+}
+
+function parseShareURL(input: string) {
+  let parsed: URL
+  try {
+    parsed = new URL(input)
+  } catch {
+    return
+  }
+  const parts = parsed.pathname.split("/").filter(Boolean)
+  if (parts.length !== 2) return
+
+  const [prefix, shareID] = parts
+  if (prefix !== "share" && prefix !== "s") return
+  if (!SHARE_ID.test(shareID)) return
+
+  const origins = new Set<string>()
+
+  const enterpriseOrigin = resolveEnterpriseOrigin(parsed.hostname)
+  if (enterpriseOrigin) origins.add(enterpriseOrigin)
+  origins.add(parsed.origin)
+
+  return {
+    shareID,
+    origins: Array.from(origins),
+  }
+}
+
+async function fetchSharePayload(origins: string[], shareID: string) {
+  const urls = origins.flatMap((origin) => [`${origin}/api/share/${shareID}/data`, `${origin}/api/share/${shareID}`])
+
+  for (const url of urls) {
+    const response = await fetch(url).catch(() => undefined)
+    if (!response?.ok) continue
+    return response.json().catch(() => undefined)
+  }
+}
+
+function normalizeSharePayload(payload: any):
+  | {
+      info: Session.Info
+      messages: Array<{
+        info: any
+        parts: any[]
+      }>
+    }
+  | undefined {
+  if (Array.isArray(payload)) {
+    let info: Session.Info | undefined
+    const messages = new Map<string, { info?: any; parts: any[] }>()
+
+    for (const item of payload) {
+      if (!item || typeof item !== "object") continue
+      if (item.type === "session") {
+        info = item.data
+        continue
+      }
+      if (item.type === "message") {
+        const messageID = item.data?.id
+        if (!messageID) continue
+        const existing = messages.get(messageID)
+        messages.set(messageID, {
+          info: item.data,
+          parts: existing?.parts ?? [],
+        })
+        continue
+      }
+      if (item.type === "part") {
+        const messageID = item.data?.messageID
+        if (!messageID) continue
+        const existing = messages.get(messageID)
+        if (existing) {
+          existing.parts.push(item.data)
+        } else {
+          messages.set(messageID, {
+            parts: [item.data],
+          })
+        }
+      }
+    }
+
+    if (!info) return
+
+    return {
+      info,
+      messages: Array.from(messages.values())
+        .filter((item): item is { info: any; parts: any[] } => Boolean(item.info))
+        .sort((a, b) => (a.info.time?.created ?? 0) - (b.info.time?.created ?? 0))
+        .map((item) => ({
+          info: item.info,
+          parts: item.parts,
+        })),
+    }
+  }
+
+  if (!payload?.info || !payload?.messages) return
+
+  return {
+    info: payload.info,
+    messages: Object.values(payload.messages).map((msg: any) => {
+      const { parts, ...info } = msg
+      return {
+        info,
+        parts,
+      }
+    }),
+  }
+}
+
+export const ImportCommand = cmd({
+  command: "import <file>",
+  describe: "import session data from JSON file or URL",
+  builder: (yargs: Argv) => {
+    return yargs.positional("file", {
+      describe: "path to JSON file or share URL",
+      type: "string",
+      demandOption: true,
+    })
+  },
+  handler: async (args) => {
+    await bootstrap(process.cwd(), async () => {
+      let exportData:
+        | {
+            info: Session.Info
+            messages: Array<{
+              info: any
+              parts: any[]
+            }>
+          }
+        | undefined
+
+      const isUrl = args.file.startsWith("http://") || args.file.startsWith("https://")
+
+      if (isUrl) {
+        const parsed = parseShareURL(args.file)
+        if (!parsed) {
+          process.stdout.write(
+            `Invalid URL format. Expected: https://nikcli.store/s/<slug> or https://s.nikcli.store/share/<slug>`,
+          )
+          process.stdout.write(EOL)
+          return
+        }
+
+        const payload = await fetchSharePayload(parsed.origins, parsed.shareID)
+        const normalized = normalizeSharePayload(payload)
+
+        if (!normalized) {
+          process.stdout.write(`Share not found: ${parsed.shareID}`)
+          process.stdout.write(EOL)
+          return
+        }
+
+        exportData = normalized
+      } else {
+        const file = Bun.file(args.file)
+        exportData = await file.json().catch(() => {})
+        if (!exportData) {
+          process.stdout.write(`File not found: ${args.file}`)
+          process.stdout.write(EOL)
+          return
+        }
+      }
+
+      if (!exportData) {
+        process.stdout.write(`Failed to read session data`)
+        process.stdout.write(EOL)
+        return
+      }
+
+      await Storage.write(["session", Instance.project.id, exportData.info.id], exportData.info)
+
+      for (const msg of exportData.messages) {
+        await Storage.write(["message", exportData.info.id, msg.info.id], msg.info)
+
+        for (const part of msg.parts) {
+          await Storage.write(["part", msg.info.id, part.id], part)
+        }
+      }
+
+      process.stdout.write(`Imported session: ${exportData.info.id}`)
+      process.stdout.write(EOL)
+    })
+  },
+})

package/src/cli/cmd/lovable.ts

@@ -0,0 +1,128 @@
+import type { Argv } from "yargs"
+import * as prompts from "@clack/prompts"
+import open from "open"
+import { cmd } from "./cmd"
+import { UI } from "../ui"
+
+const LOVABLE_BASE_URL = "https://lovable.dev/"
+const LOVABLE_PROMPT_MAX = 50000
+const LOVABLE_IMAGES_MAX = 10
+
+function buildUrl(prompt: string, images: string[]) {
+  const url = new URL(LOVABLE_BASE_URL)
+  url.searchParams.set("autosubmit", "true")
+  const params = new URLSearchParams()
+  params.set("prompt", prompt)
+  for (const image of images) {
+    params.append("images", image)
+  }
+  url.hash = params.toString()
+  return url.toString()
+}
+
+function toArray(value: string[] | string | undefined) {
+  if (Array.isArray(value)) return value
+  if (typeof value === "string") return [value]
+  return []
+}
+
+function normalizeImages(images: string[]) {
+  return images.map((item) => item.trim()).filter((item) => item.length > 0)
+}
+
+function findInvalidImage(images: string[]) {
+  return images.find((item) => !item.startsWith("http://") && !item.startsWith("https://"))
+}
+
+export const LovableCommand = cmd({
+  command: "lovable",
+  describe: "build Lovable apps from your terminal",
+  builder: (yargs) => yargs.command(LovableBuildCommand).demandCommand(),
+  async handler() {},
+})
+
+export const LovableBuildCommand = cmd({
+  command: "build",
+  describe: "build a Lovable app using Build with URL",
+  builder: (yargs: Argv) =>
+    yargs
+      .option("prompt", {
+        type: "string",
+        describe: "app prompt",
+      })
+      .option("image", {
+        type: "string",
+        describe: "reference image URL (repeatable)",
+        array: true,
+      })
+      .option("open", {
+        type: "boolean",
+        describe: "open the build URL in your browser",
+        default: true,
+      }),
+  async handler(args) {
+    UI.empty()
+    prompts.intro("Lovable Build")
+
+    const promptInput =
+      typeof args.prompt === "string"
+        ? args.prompt
+        : await prompts.text({
+            message: "Describe the app to build",
+            validate: (input) => {
+              if (!input || input.trim().length === 0) return "Required"
+              if (input.length > LOVABLE_PROMPT_MAX) return `Max ${LOVABLE_PROMPT_MAX} characters`
+              return undefined
+            },
+          })
+
+    if (prompts.isCancel(promptInput)) throw new UI.CancelledError()
+
+    const prompt = promptInput.trim()
+    if (!prompt) {
+      prompts.log.error("Prompt is required")
+      prompts.outro("Done")
+      return
+    }
+    if (prompt.length > LOVABLE_PROMPT_MAX) {
+      prompts.log.error(`Prompt exceeds ${LOVABLE_PROMPT_MAX} characters`)
+      prompts.outro("Done")
+      return
+    }
+
+    const images = normalizeImages(toArray(args.image))
+    if (images.length > LOVABLE_IMAGES_MAX) {
+      prompts.log.error(`Use up to ${LOVABLE_IMAGES_MAX} image URLs`)
+      prompts.outro("Done")
+      return
+    }
+    const invalid = findInvalidImage(images)
+    if (invalid) {
+      prompts.log.error(`Invalid image URL: ${invalid}`)
+      prompts.outro("Done")
+      return
+    }
+
+    const url = buildUrl(prompt, images)
+    prompts.log.warn("Do not paste API keys in the prompt. Use Lovable secrets for credentials.")
+    prompts.log.info("Build URL:")
+    prompts.log.info(url)
+    prompts.log.info("If you are not logged in, Lovable will ask you to sign in and choose a workspace.")
+
+    if (!args.open) {
+      prompts.outro("Done")
+      return
+    }
+
+    const opened = await open(url)
+      .then(() => true)
+      .catch(() => false)
+
+    if (!opened) {
+      prompts.log.warn("Could not open the browser. Open this URL manually:")
+      prompts.log.info(url)
+    }
+
+    prompts.outro("Done")
+  },
+})