phio 0.2.4 → 0.3.0

package/README.md

@@ -39,7 +39,7 @@ Use `pockethost` in your `package.json` to save your instance name so you don't
 // package.json
 {
   "pockethost": {
-    "instanceId": "all-your-base"
+    "instanceName": "all-your-base"
   }
 }
 ```
@@ -50,6 +50,16 @@ Use `pockethost.json` to save your instance name so you don't need to keep typin
 
 ```json
 {
-    "instanceId": "all-your-base'
+  "instanceName": "all-your-base"
 }
 ```
+
+## Environment Variables
+
+The following environment variables can be used to override any saved configuration:
+
+- `PHIO_USERNAME` - Override saved username
+- `PHIO_PASSWORD` - Override saved password
+- `PHIO_INSTANCE_NAME` - Override saved instance name
+
+Environment variables take precedence over configuration in package.json or pockethost.json.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phio",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "A CLI tool to manage your PocketHost instances",
   "repository": {
     "type": "git",
@@ -28,11 +28,8 @@
     "@types/node": "^22.5.5",
     "prettier-plugin-organize-imports": "^4.0.0"
   },
-  "peerDependencies": {
-    "typescript": "^5.6.2"
-  },
   "scripts": {
-    "dev": "tsx --watch ./src/index.ts"
+    "dev": "tsx ./src/cli.ts"
   },
   "bin": {
     "phio": "src/cli.ts"
@@ -56,7 +53,8 @@
     "multimatch": "^7.0.0",
     "ora": "^8.1.0",
     "pocketbase": "^0.21.5",
-    "tsx": "^4.19.1"
+    "tsx": "^4.19.1",
+    "typescript": "^5.6.2"
   },
   "prettier": {
     "semi": false,

package/src/cli.ts

@@ -3,6 +3,7 @@ import { program } from 'commander'
 import { version } from '../package.json'
 import { DeployCommand } from './commands/DeployCommand'
 import { DevCommand } from './commands/DevCommand'
+import { InfoCommand } from './commands/InfoCommand'
 import { LinkCommand } from './commands/LinkCommand'
 import { ListCommand } from './commands/ListCommand'
 import { LoginCommand } from './commands/LoginCommand'
@@ -20,5 +21,19 @@ program
   .addCommand(ListCommand())
   .addCommand(LinkCommand())
   .addCommand(DeployCommand())
+  .addCommand(InfoCommand())
 
-program.parseAsync(process.argv).catch(console.error)
+// Add error handling
+program.exitOverride()
+
+program.parseAsync(process.argv).catch((err) => {
+  // Handle specific commander error types
+  if (err.code === 'commander.unknownCommand') {
+    console.error('Error: Unknown command')
+  } else if (err.code === 'commander.missingArgument') {
+    console.error('Error: Missing required argument')
+  } else {
+    console.error('Error:', err.message)
+  }
+  process.exit(1)
+})

package/src/commands/DeployCommand.ts

@@ -1,10 +1,10 @@
 import { Command } from 'commander'
-import { savedInstanceId } from '../lib/defaultInstanceId'
+import { savedInstanceName } from '../lib/defaultInstanceId'
 import { DEFAULT_EXCLUDES, DEFAULT_INCLUDES, deployMyCode } from './DevCommand'
 
 export const DeployCommand = () => {
   return new Command(`deploy`)
-    .argument(`[instanceId]`, `Instance name`, savedInstanceId())
+    .argument(`[instanceName]`, `Instance name`, savedInstanceName())
     .description(`Deploy to remote`)
     .option(`-v, --verbose`, `Verbose output`)
     .option(
@@ -21,8 +21,8 @@ export const DeployCommand = () => {
       },
       DEFAULT_EXCLUDES
     )
-    .action((instanceId, options) => {
+    .action((instanceName, options) => {
       const { include, exclude, verbose } = options
-      deployMyCode(instanceId, include, exclude, verbose)
+      deployMyCode(instanceName, include, exclude, verbose)
     })
 }

package/src/commands/DevCommand.ts

@@ -4,11 +4,10 @@ import { IFtpDeployArguments } from '@samkirkland/ftp-deploy/src/types'
 import Bottleneck from 'bottleneck'
 import { watch } from 'chokidar'
 import { Command } from 'commander'
-import { ensureDirSync } from 'fs-extra'
 import multimatch from 'multimatch'
 import { config } from '../lib/config'
 import { getInstanceBySubdomainCnameOrId } from '../lib/getClient'
-import { savedInstanceId } from './../lib/defaultInstanceId'
+import { savedInstanceName } from './../lib/defaultInstanceId'
 
 export const DEFAULT_INCLUDES = [
   `pb_*`,
@@ -93,10 +92,7 @@ export async function deployMyCode(
   exclude: string[],
   verbose: boolean
 ) {
-  const cachePath = '.cache'
-  ensureDirSync(cachePath)
-
-  console.log('🚚 Deploy started')
+  console.log(`🚚 Deploy started for ${instanceName}`)
   const args: IFtpDeployArguments = {
     server: 'ftp.pockethost.io',
     username: `__auth__`,
@@ -104,18 +100,16 @@ export async function deployMyCode(
     'server-dir': `${instanceName}/`,
     include,
     exclude: [...excludeDefaults, ...exclude],
-    'log-level': verbose ? 'verbose' : 'standard',
+    'log-level': verbose ? 'verbose' : 'minimal',
   }
 
-  console.log({ args })
-
   await deploy(args)
   console.log('🚀 Deploy done!')
 }
 
 export const DevCommand = () => {
   return new Command('dev')
-    .argument(`[instanceId]`, `Instance name`, savedInstanceId())
+    .argument(`[instanceId]`, `Instance name`, savedInstanceName())
     .description(`Watch for local modifications and sync to remote`)
     .option(`-v, --verbose`, `Verbose output`)
     .option(

package/src/commands/InfoCommand.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander'
+import { PHIO_HOME } from '../lib/constants'
+import { savedInstanceName } from '../lib/defaultInstanceId'
+
+export const InfoCommand = () => {
+  return new Command(`info`).description(`Get config info`).action(() => {
+    console.log(`Config root: ${PHIO_HOME()}`)
+    console.log(`Instance: ${savedInstanceName()}`)
+  })
+}

package/src/commands/LinkCommand.ts

@@ -1,38 +1,44 @@
 import { select } from '@inquirer/prompts'
 import { Command } from 'commander'
-import { config } from '../lib/config'
-import { saveInstanceId } from '../lib/defaultInstanceId'
+import { saveInstanceName } from '../lib/defaultInstanceId'
 import { InstanceFields } from '../lib/InstanceFields'
 import { getClient, getInstanceBySubdomainCnameOrId } from './../lib/getClient'
 
-export const isLinked = () => !!config('instanceId')
-
-export const link = async (instanceNameOrId: string) => {
-  saveInstanceId(instanceNameOrId, 'package.json')
-  const instance = await getInstanceBySubdomainCnameOrId(instanceNameOrId)
+export const link = async (instanceName: string) => {
+  saveInstanceName(instanceName, 'package.json')
+  const instance = await getInstanceBySubdomainCnameOrId(instanceName)
   if (!instance) {
     return
   }
-  config('instanceId', instance.subdomain)
   return instance
 }
 
 export const linkWithUserInput = async () => {
-  const client = getClient()
+  const client = await getClient()
   const instances = await client
     .collection(`instances`)
     .getFullList<InstanceFields>()
+
+  if (instances.length === 0) {
+    console.error(
+      `No instances found. If this seems wrong, use 'phio login' to log in, then try again.`
+    )
+    return
+  }
+
   while (true) {
-    const instanceNameOrId = await select({
+    const instanceName = 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,
-      })),
+      choices: instances
+        .sort((a, b) => a.subdomain.localeCompare(b.subdomain))
+        .map((instance) => ({
+          name: `${instance.subdomain} (${instance.id}) ${
+            instance.cname ? `(${instance.cname})` : ''
+          } (${instance.status.toUpperCase()})`,
+          value: instance.subdomain,
+        })),
     })
-    const instance = await link(instanceNameOrId)
+    const instance = await link(instanceName)
     if (!instance) {
       console.error(`Instance not found`)
       continue

package/src/commands/ListCommand.ts

@@ -4,18 +4,21 @@ import { InstanceFields } from './../lib/InstanceFields'
 
 export const ListCommand = () => {
   return new Command(`list`)
+    .alias(`ls`)
     .description(`List all the logs`)
     .action(async () => {
-      const client = getClient()
+      const client = await getClient()
       const instances = await client
         .collection(`instances`)
         .getFullList<InstanceFields>()
-      instances.forEach((instance) => {
-        console.log(
-          `- ${instance.subdomain} (${instance.id}) ${
-            instance.cname ? `(${instance.cname})` : ''
-          } (${instance.status.toUpperCase()})`
-        )
-      })
+      instances
+        .sort((a, b) => a.subdomain.localeCompare(b.subdomain))
+        .forEach((instance) => {
+          console.log(
+            `- ${instance.subdomain} (${instance.id}) ${
+              instance.cname ? `(${instance.cname})` : ''
+            } (${instance.status.toUpperCase()})`
+          )
+        })
     })
 }

package/src/commands/LoginCommand.ts

@@ -2,10 +2,16 @@ import { input, password } from '@inquirer/prompts'
 import { Command } from 'commander'
 import * as EmailValidator from 'email-validator'
 import { config } from '../lib/config'
-import { getClient } from './../lib/getClient'
-import { runTasks } from './../lib/Task'
+import { PHIO_USERNAME } from '../lib/constants'
+import { login } from './../lib/getClient'
 
 export const loginWithUserInput = async () => {
+  if (PHIO_USERNAME()) {
+    throw new Error(
+      'Cannot login with username and password if PHIO_USERNAME is set'
+    )
+  }
+
   while (true) {
     const email = await input({
       message: 'Enter your pockethost.io email address',
@@ -24,29 +30,20 @@ export const loginWithUserInput = async () => {
 
     config(`email`, email)
 
-    const client = getClient()
     try {
-      await runTasks([
-        {
-          name: `Logging in`,
-          run: async () => {
-            const res = await client
-              .collection('users')
-              .authWithPassword(email, pw)
-          },
-        },
-      ])
+      const authStore = await login(email, pw)
+
+      config(`auth`, {
+        token: authStore.exportToCookie(),
+        record: authStore.model,
+      })
     } catch (e) {
       console.error(
-        `There was an error logging in. Please try again or go to https://pockethost.io to reset your password.`
+        `There was an error logging in. Please try again or go to https://pockethost.io to reset your password. (${e})`
       )
       continue
     }
 
-    config(`auth`, {
-      token: client.authStore.exportToCookie(),
-      record: client.authStore.model,
-    })
     break
   }
   console.log(`Logged in!`)

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 { savedInstanceId } from '../lib/defaultInstanceId'
+import { savedInstanceName } from '../lib/defaultInstanceId'
 import { ensureLoggedIn } from '../lib/ensureLoggedIn'
 
 export enum StreamNames {
@@ -70,7 +70,7 @@ const watchInstanceLog = async (
 export const LogsCommand = () => {
   return new Command('logs')
     .description(`Tail instance logs`)
-    .argument('[instance]', 'Instance ID', savedInstanceId())
+    .argument('[instance]', 'Instance ID', savedInstanceName())
     .action((instance) => {
       watchInstanceLog(instance, (log) => {
         const { time, message, stream } = log

package/src/lib/config.ts

@@ -1,9 +1,9 @@
-import { readJSONSync, writeJSONSync } from 'fs-extra/esm'
+import fse from 'fs-extra'
 import { type AuthModel } from 'pocketbase'
 import { PHIO_HOME } from './constants'
 
+const { readJSONSync, writeJSONSync } = fse
 export type Config = {
-  instanceId: string
   email: string
   auth: { record: AuthModel; token: string }
 }

package/src/lib/constants.ts

@@ -1,8 +1,10 @@
 import envPaths from 'env-paths'
 import env from 'env-var'
-import { ensureDirSync } from 'fs-extra/esm'
+import fse from 'fs-extra'
 import { join } from 'path'
 
+const { ensureDirSync } = fse
+
 export const PHIO_HOME = (...paths: string[]) =>
   join(
     env.get('PHIO_HOME').default(envPaths(`phio`).config).asString(),
@@ -20,3 +22,8 @@ export const PHIO_MOTHERSHIP_URL = (...paths: string[]) => {
   url.pathname = join(url.pathname, ...paths)
   return url.toString()
 }
+
+export const PHIO_USERNAME = () => env.get('PHIO_USERNAME').asString() || ''
+export const PHIO_PASSWORD = () => env.get('PHIO_PASSWORD').asString() || ''
+export const PHIO_INSTANCE_NAME = () =>
+  env.get('PHIO_INSTANCE_NAME').asString() || ''

package/src/lib/defaultInstanceId.ts

@@ -1,29 +1,35 @@
 import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { PHIO_INSTANCE_NAME } from './constants'
 
-export const savedInstanceId = () => {
+export const savedInstanceName = () => {
+  if (PHIO_INSTANCE_NAME()) {
+    return PHIO_INSTANCE_NAME()
+  }
   if (existsSync('package.json')) {
     const pkg = JSON.parse(readFileSync('package.json').toString())
-    if (pkg.pockethost?.instanceId) {
-      return pkg.pockethost.instanceId
+    if (pkg.pockethost?.instanceName) {
+      return pkg.pockethost.instanceName
     }
   }
   if (existsSync('pockethost.json')) {
     const pkg = JSON.parse(readFileSync('pockethost.json').toString())
-    if (pkg.instanceId) {
-      return pkg.instanceId
+    if (pkg.instanceName) {
+      return pkg.instanceName
     }
   }
   return null
 }
 
-export const saveInstanceId = (
-  instanceId: string,
+export const saveInstanceName = (
+  instanceName: string,
   file: 'package.json' | 'pockethost.json'
 ) => {
   if (!existsSync(file)) {
     // Create new file if it doesn't exist
     const newContent =
-      file === 'package.json' ? { pockethost: { instanceId } } : { instanceId }
+      file === 'package.json'
+        ? { pockethost: { instanceName } }
+        : { instanceName }
     writeFileSync(file, JSON.stringify(newContent, null, 2))
     return
   }
@@ -33,9 +39,9 @@ export const saveInstanceId = (
 
   if (file === 'package.json') {
     content.pockethost = content.pockethost || {}
-    content.pockethost.instanceId = instanceId
+    content.pockethost.instanceName = instanceName
   } else {
-    content.instanceId = instanceId
+    content.instanceName = instanceName
   }
 
   writeFileSync(file, JSON.stringify(content, null, 2))

package/src/lib/ensureLoggedIn.ts

@@ -1,18 +1,8 @@
-import { config } from '../lib/config'
 import { getClient } from '../lib/getClient'
 
 export const ensureLoggedIn = async () => {
-  try {
-    const token = config(`auth`)!.token
-    const client = getClient()
-    client.authStore.loadFromCookie(token)
-    await client.collection(`users`).authRefresh()
-    config(`auth`, {
-      token: client.authStore.exportToCookie(),
-      record: client.authStore.model,
-    })
-  } catch (e) {
-    console.error(`You must be logged in first. Use 'phio login'`)
-    process.exit(1)
+  const client = await getClient()
+  if (!client.authStore.isValid) {
+    throw new Error(`You must be logged in first. Use 'phio login'`)
   }
 }

package/src/lib/getClient.ts

@@ -1,26 +1,81 @@
 import PocketBase from 'pocketbase'
+import { runTasks } from './../lib/Task'
 import { config } from './config'
-import { PHIO_MOTHERSHIP_URL } from './constants'
+import { PHIO_MOTHERSHIP_URL, PHIO_PASSWORD, PHIO_USERNAME } from './constants'
 
-export const getClient = () => {
-  const client = new PocketBase(PHIO_MOTHERSHIP_URL())
-  const { record, token } = config('auth') || {}
-  // console.log({ record, token })
-  if (record && token) {
+let client: PocketBase | undefined
+export const getClient = async () => {
+  if (client) {
+    return client
+  }
+  client = new PocketBase(PHIO_MOTHERSHIP_URL())
+
+  if (PHIO_USERNAME()) {
+    try {
+      await unsafeLogin(PHIO_USERNAME(), PHIO_PASSWORD())
+      return client
+    } catch (e) {
+      throw new Error(
+        `There was an error logging in. Please try again or go to https://pockethost.io to reset your password.`
+      )
+    }
+  }
+
+  const authStore = config('auth')
+  if (authStore) {
+    const { record, token } = authStore
     client.authStore.loadFromCookie(token)
     // console.log({ valid: client.authStore.isValid })
     client.authStore.onChange((token, record) => {
-      config('auth', { token: client.authStore.exportToCookie(), record })
+      if (!client) {
+        console.warn('No client found - please report this bug')
+        return
+      }
+      config('auth', {
+        token: client.authStore.exportToCookie(),
+        record: client.authStore.model,
+      })
+    })
+    await client.collection(`users`).authRefresh()
+    config(`auth`, {
+      token: client.authStore.exportToCookie(),
+      record: client.authStore.model,
     })
   }
   return client
 }
 
 export const getInstanceBySubdomainCnameOrId = async (search: string) => {
-  const client = getClient()
+  const client = await getClient()
   return await client
     .collection(`instances`)
     .getFirstListItem(
       `id='${search}' || subdomain='${search}' || cname='${search}'`
     )
 }
+
+const unsafeLogin = async (username: string, password: string) => {
+  if (!client) {
+    throw new Error('No client found')
+  }
+  await runTasks([
+    {
+      name: `Logging in`,
+      run: async () => {
+        if (!client) {
+          throw new Error('No client found')
+        }
+        const res = await client
+          .collection('users')
+          .authWithPassword(username, password)
+      },
+    },
+  ])
+  return client.authStore
+}
+
+export const login = async (username: string, password: string) => {
+  const client = await getClient()
+  await unsafeLogin(username, password)
+  return client.authStore
+}