phio 0.1.2 → 0.2.0

package/README.md

@@ -19,10 +19,10 @@ bunx phio list
 bunx phio dev [instance]
 ```
 
-**Bi-directional sync**
+**Deploy to remote**
 
 ```bash
-bunx phio sync [instance]
+bunx phio deploy [instance]
 ```
 
 **Tail logs**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phio",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "A CLI tool to manage your PocketHost instances",
   "repository": {
     "type": "git",
@@ -17,8 +17,10 @@
   "bugs": {
     "url": "https://github.com/pockethost/phio/issues"
   },
+  "main": "src/index.ts",
   "module": "src/index.ts",
   "type": "module",
+  "types": "src/index.ts",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/fs-extra": "^11.0.4",
@@ -32,7 +34,7 @@
     "dev": "tsx --watch ./src/index.ts"
   },
   "bin": {
-    "phio": "src/index.ts"
+    "phio": "src/cli.ts"
   },
   "files": [
     "src"

package/src/cli.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env tsx
+import { program } from 'commander'
+import { version } from '../package.json'
+import { DeployCommand } from './commands/DeployCommand'
+import { DevCommand } from './commands/DevCommand'
+import { LinkCommand } from './commands/LinkCommand'
+import { ListCommand } from './commands/ListCommand'
+import { LoginCommand } from './commands/LoginCommand'
+import { LogsCommand } from './commands/LogsCommand'
+import { WhoAmICommand } from './commands/WhoAmICommand'
+
+program
+  .name(`PocketHost CLI`)
+  .version(version)
+  .description(`CLI access to phio`)
+  .addCommand(LoginCommand())
+  .addCommand(LogsCommand())
+  .addCommand(DevCommand())
+  .addCommand(WhoAmICommand())
+  .addCommand(ListCommand())
+  .addCommand(LinkCommand())
+  .addCommand(DeployCommand())
+
+program.parseAsync(process.argv).catch(console.error)

package/src/commands/DeployCommand.ts

@@ -0,0 +1,26 @@
+import { Command } from 'commander'
+import { savedInstanceId } from '../lib/defaultInstanceId'
+import { DEFAULT_EXCLUDES, DEFAULT_INCLUDES, deployMyCode } from './DevCommand'
+
+export const DeployCommand = () => {
+  return new Command(`deploy`)
+    .argument(`[instanceId]`, `Instance name`, savedInstanceId())
+    .description(`Deploy to remote`)
+    .option(`-v, --verbose`, `Verbose output`)
+    .option(
+      '-i, --include <include...>',
+      'Files to include in the sync',
+      (val, prev) => [...prev, val],
+      DEFAULT_INCLUDES
+    )
+    .option(
+      '-e, --exclude <exclude...>',
+      'Files to exclude from the sync',
+      (val, prev) => [...prev, val],
+      DEFAULT_EXCLUDES
+    )
+    .action((instanceId, options) => {
+      const { include, exclude, verbose } = options
+      deployMyCode(instanceId, include, exclude, verbose)
+    })
+}

package/src/commands/DevCommand.ts

@@ -7,9 +7,86 @@ import { ensureDirSync } from 'fs-extra'
 import multimatch from 'multimatch'
 import { config } from '../lib/config'
 import { getInstanceBySubdomainCnameOrId } from '../lib/getClient'
-import { defaultInstanceId } from './../lib/defaultInstanceId'
+import { savedInstanceId } from './../lib/defaultInstanceId'
 
-async function deployMyCode(
+export const DEFAULT_INCLUDES = [
+  `pb_*`,
+  'pb_*/**/*',
+  `package.json`,
+  `bun.lockb`,
+  `patches`,
+  `patches/**/*`,
+]
+
+export const DEFAULT_EXCLUDES = [`pb_data`, `pb_data/**/*`]
+
+export type DeployOptions = {
+  include: string[]
+  exclude: string[]
+  verbose: boolean
+}
+
+export const watchAndDeploy = async (
+  _instanceId: string,
+  options: DeployOptions = {
+    include: DEFAULT_INCLUDES,
+    exclude: DEFAULT_EXCLUDES,
+    verbose: false,
+  }
+) => {
+  if (!_instanceId) {
+    console.error(
+      `No instance name provided and none was found in package.json or pockethost.json. Use 'phio link <instance>'`
+    )
+    process.exit(1)
+  }
+  console.log(`Dev mode`)
+  const { include, exclude, verbose } = options
+  // console.log({ include, exclude })
+
+  const instance = await getInstanceBySubdomainCnameOrId(_instanceId)
+
+  const limiter = new Bottleneck({ maxConcurrent: 1 })
+  const upload = debounce(
+    () =>
+      limiter.schedule(() =>
+        deployMyCode(instance.subdomain, include, exclude, verbose).catch(
+          console.error
+        )
+      ),
+    200
+  )
+
+  const watcher = watch('.', {
+    persistent: true,
+    ignored: (file) => {
+      if (file === '.') return false
+      const isIncluded = multimatch([file], include).length > 0
+      const isExcluded = multimatch([file], exclude).length > 0
+      const isIgnored = !isIncluded || isExcluded
+      // console.log({
+      //   file,
+      //   include,
+      //   isIncluded,
+      //   exclude,
+      //   isExcluded,
+      //   isIgnored,
+      // })
+      return isIgnored
+    },
+  })
+  console.log(
+    `Watching for changes in ${include.join(', ')} and excluding ${exclude.join(', ')}`
+  )
+  const handle = (path: string, details: any) => {
+    upload()
+    // internal
+    // console.log(`Syncing ${path}`)
+  }
+  watcher.on('add', handle).on('change', handle).on('unlink', handle)
+}
+
+export async function deployMyCode(
   instanceName: string,
   include: string[],
   exclude: string[],
@@ -33,77 +110,20 @@ async function deployMyCode(
 
 export const DevCommand = () => {
   return new Command('dev')
-    .argument(`[instanceId]`, `Instance name`, defaultInstanceId())
+    .argument(`[instanceId]`, `Instance name`, savedInstanceId())
     .description(`Watch for local modifications and sync to remote`)
     .option(`-v, --verbose`, `Verbose output`)
     .option(
       '-i, --include <include...>',
       'Files to include in the sync',
       (val, prev) => [...prev, val],
-      [
-        `pb_*`,
-        'pb_*/**/*',
-        `package.json`,
-        `bun.lockb`,
-        `patches`,
-        `patches/**/*`,
-      ]
+      DEFAULT_INCLUDES
     )
     .option(
       '-e, --exclude <exclude...>',
       'Files to exclude from the sync',
       (val, prev) => [...prev, val],
-      [`pb_data`, `pb_data/**/*`]
+      DEFAULT_EXCLUDES
     )
-    .action(async (_instanceId, { include, exclude, verbose }) => {
-      if (!_instanceId) {
-        console.error(
-          `No instance name provided and none was found in package.json or pockethost.json. Use 'phio link <instance>'`
-        )
-        process.exit(1)
-      }
-      console.log(`Dev mode`)
-      // console.log({ include, exclude })
-
-      const instance = await getInstanceBySubdomainCnameOrId(_instanceId)
-
-      const limiter = new Bottleneck({ maxConcurrent: 1 })
-      const upload = debounce(
-        () =>
-          limiter.schedule(() =>
-            deployMyCode(instance.subdomain, include, exclude, verbose).catch(
-              console.error
-            )
-          ),
-        200
-      )
-
-      const watcher = watch('.', {
-        persistent: true,
-        ignored: (file) => {
-          if (file === '.') return false
-          const isIncluded = multimatch([file], include).length > 0
-          const isExcluded = multimatch([file], exclude).length > 0
-          const isIgnored = !isIncluded || isExcluded
-          // console.log({
-          //   file,
-          //   include,
-          //   isIncluded,
-          //   exclude,
-          //   isExcluded,
-          //   isIgnored,
-          // })
-          return isIgnored
-        },
-      })
-      console.log(
-        `Watching for changes in ${include.join(', ')} and excluding ${exclude.join(', ')}`
-      )
-      const handle = (path: string, details: any) => {
-        upload()
-        // internal
-        // console.log(`Syncing ${path}`)
-      }
-      watcher.on('add', handle).on('change', handle).on('unlink', handle)
-    })
+    .action(watchAndDeploy)
 }

package/src/commands/LinkCommand.ts

@@ -1,21 +1,59 @@
+import { select } from '@inquirer/prompts'
 import { Command } from 'commander'
-import { readJSONSync, writeJSONSync } from 'fs-extra/esm'
-import { getInstanceBySubdomainCnameOrId } from './../lib/getClient'
+import { config } from '../lib/config'
+import { InstanceFields } from '../lib/InstanceFields'
+import { getClient, getInstanceBySubdomainCnameOrId } from './../lib/getClient'
+
+export const isLinked = () => !!config('instanceId')
+
+export const link = async (instanceNameOrId: string) => {
+  const instance = await getInstanceBySubdomainCnameOrId(instanceNameOrId)
+  if (!instance) {
+    return
+  }
+  config('instanceId', instance.subdomain)
+  return instance
+}
+
+export const linkWithUserInput = async () => {
+  const client = getClient()
+  const instances = await client
+    .collection(`instances`)
+    .getFullList<InstanceFields>()
+  while (true) {
+    const instanceNameOrId = await select({
+      message: `Choose the instance you'd like to link`,
+      choices: instances.map((instance) => ({
+        name: `${instance.subdomain} (${instance.id}) ${
+          instance.cname ? `(${instance.cname})` : ''
+        } (${instance.status.toUpperCase()})`,
+        value: instance.subdomain,
+      })),
+    })
+    const instance = await link(instanceNameOrId)
+    if (!instance) {
+      console.error(`Instance not found`)
+      continue
+    }
+    console.log(`Linked ${instance.subdomain}`)
+    break
+  }
+}
 
 export const LinkCommand = () => {
   return new Command(`link`)
-    .argument(`<instance>`, `Instance name or ID`)
+    .argument(`[instance]`, `Instance name or ID`)
     .description(`Link a local directory to a remote instance`)
     .action(async (_anyName) => {
-      const instance = await getInstanceBySubdomainCnameOrId(_anyName)
-      if (!instance) {
-        console.error(`Instance not found`)
-        process.exit(1)
+      if (_anyName) {
+        const instance = await link(_anyName)
+        if (!instance) {
+          console.error(`Instance ${_anyName} not found`)
+          process.exit(1)
+        }
+        console.log(`Linked ${instance.subdomain}`)
+        return
       }
-      console.log(`Instance found: ${instance.subdomain}`)
-      const pkg = readJSONSync(`package.json`)
-      pkg.pockethost = { instanceId: instance.subdomain }
-      console.log(`Writing to package.json`)
-      writeJSONSync(`package.json`, pkg, { spaces: 2 })
+      await linkWithUserInput()
     })
 }

package/src/commands/LoginCommand.ts

@@ -5,53 +5,55 @@ import { config } from '../lib/config'
 import { getClient } from './../lib/getClient'
 import { runTasks } from './../lib/Task'
 
-export const LoginCommand = () =>
-  new Command('login')
-    .description(`Log in to PocketHost`)
-    .helpOption(false)
-    .action(async () => {
-      while (true) {
-        const email = await input({
-          message: 'Enter your pockethost.io email address',
-          default: config('email'),
-          validate: (input: string) => {
-            if (!EmailValidator.validate(input)) {
-              return 'Invalid email address'
-            }
-            return true
-          },
-        })
+export const loginWithUserInput = async () => {
+  while (true) {
+    const email = await input({
+      message: 'Enter your pockethost.io email address',
+      default: config('email'),
+      validate: (input: string) => {
+        if (!EmailValidator.validate(input)) {
+          return 'Invalid email address'
+        }
+        return true
+      },
+    })
 
-        const pw = await password({
-          message: 'Enter your pockethost.io password',
-        })
+    const pw = await password({
+      message: 'Enter your pockethost.io password',
+    })
 
-        config(`email`, email)
+    config(`email`, email)
 
-        const client = getClient()
-        try {
-          await runTasks([
-            {
-              name: `Logging in`,
-              run: async () => {
-                const res = await client
-                  .collection('users')
-                  .authWithPassword(email, pw)
-              },
-            },
-          ])
-        } catch (e) {
-          console.error(
-            `There was an error logging in. Please try again or go to https://pockethost.io to reset your password.`
-          )
-          continue
-        }
+    const client = getClient()
+    try {
+      await runTasks([
+        {
+          name: `Logging in`,
+          run: async () => {
+            const res = await client
+              .collection('users')
+              .authWithPassword(email, pw)
+          },
+        },
+      ])
+    } catch (e) {
+      console.error(
+        `There was an error logging in. Please try again or go to https://pockethost.io to reset your password.`
+      )
+      continue
+    }
 
-        config(`auth`, {
-          token: client.authStore.exportToCookie(),
-          record: client.authStore.model,
-        })
-        break
-      }
-      console.log(`Logged in!`)
+    config(`auth`, {
+      token: client.authStore.exportToCookie(),
+      record: client.authStore.model,
     })
+    break
+  }
+  console.log(`Logged in!`)
+}
+
+export const LoginCommand = () =>
+  new Command('login')
+    .description(`Log in to PocketHost`)
+    .helpOption(false)
+    .action(loginWithUserInput)

package/src/commands/LogsCommand.ts

@@ -1,7 +1,7 @@
 import { fetchEventSource } from '@sentool/fetch-event-source'
 import { Command } from 'commander'
 import { config } from '../lib/config'
-import { defaultInstanceId } from '../lib/defaultInstanceId'
+import { savedInstanceId } from '../lib/defaultInstanceId'
 
 export enum StreamNames {
   StdOut = 'stdout',
@@ -64,7 +64,7 @@ const watchInstanceLog = (
 export const LogsCommand = () => {
   return new Command('logs')
     .description(`Tail instance logs`)
-    .argument('[instance]', 'Instance ID', defaultInstanceId())
+    .argument('[instance]', 'Instance ID', savedInstanceId())
     .action((instance) => {
       watchInstanceLog(instance, (log) => {
         const { time, message, stream } = log

package/src/index.ts

@@ -1,22 +1,11 @@
-#!/usr/bin/env tsx
-import { program } from 'commander'
-import { version } from '../package.json'
-import { DevCommand } from './commands/DevCommand'
-import { LinkCommand } from './commands/LinkCommand'
-import { ListCommand } from './commands/ListCommand'
-import { LoginCommand } from './commands/LoginCommand'
-import { LogsCommand } from './commands/LogsCommand'
-import { WhoAmICommand } from './commands/WhoAmICommand'
+import { config } from './lib/config'
 
-program
-  .name(`PocketHost CLI`)
-  .version(version)
-  .description(`CLI access to phio`)
-  .addCommand(LoginCommand())
-  .addCommand(LogsCommand())
-  .addCommand(DevCommand())
-  .addCommand(WhoAmICommand())
-  .addCommand(ListCommand())
-  .addCommand(LinkCommand())
+export const isLoggedIn = () => {
+  return !!config('auth')
+}
 
-program.parseAsync(process.argv).catch(console.error)
+export * from './commands/DevCommand'
+export * from './commands/LinkCommand'
+export * from './commands/LoginCommand'
+export { config } from './lib/config'
+export { getClient } from './lib/getClient'

package/src/lib/config.ts

@@ -3,6 +3,7 @@ import { type AuthModel } from 'pocketbase'
 import { PHIO_HOME } from './constants'
 
 export type Config = {
+  instanceId: string
   email: string
   auth: { record: AuthModel; token: string }
 }

package/src/lib/defaultInstanceId.ts

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'fs'
 
-export const defaultInstanceId = () => {
+export const savedInstanceId = () => {
   if (existsSync('package.json')) {
     const pkg = JSON.parse(readFileSync('package.json').toString())
     if (pkg.pockethost?.instanceId) {