phio 0.3.3 → 0.3.5

package/README.md

@@ -4,6 +4,7 @@
 
 ```bash
 bunx phio login
+bunx phio logout
 bunx phio whoami
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phio",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "A CLI tool to manage your PocketHost instances",
   "repository": {
     "type": "git",
@@ -41,7 +41,7 @@
     "@inquirer/prompts": "^7.3.2",
     "@s-libs/micro-dash": "^18.0.0",
     "@samkirkland/ftp-deploy": "github:benallfree/ftp-deploy#132389e",
-    "@sentool/fetch-event-source": "^0.6.0",
+    "@sentool/fetch-event-source": "github:pockethost/sentool-fetch-event-source#c975adc3cdf9c645bf094b0b8a28454699075e22",
     "bottleneck": "^2.19.5",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

package/src/cli.ts

@@ -7,6 +7,7 @@ import { InfoCommand } from './commands/InfoCommand'
 import { LinkCommand } from './commands/LinkCommand'
 import { ListCommand } from './commands/ListCommand'
 import { LoginCommand } from './commands/LoginCommand'
+import { LogoutCommand } from './commands/LogoutCommand'
 import { LogsCommand } from './commands/LogsCommand'
 import { WhoAmICommand } from './commands/WhoAmICommand'
 
@@ -21,6 +22,7 @@ program
   .addCommand(ListCommand())
   .addCommand(LinkCommand())
   .addCommand(DeployCommand())
+  .addCommand(LogoutCommand())
   .addCommand(InfoCommand())
 
 // Add error handling

package/src/commands/DeployCommand.ts

@@ -21,8 +21,8 @@ export const DeployCommand = () => {
       },
       DEFAULT_EXCLUDES
     )
-    .action((instanceName, options) => {
+    .action(async (instanceName, options) => {
       const { include, exclude, verbose } = options
-      deployMyCode(instanceName, include, exclude, verbose)
+      await deployMyCode(instanceName, include, exclude, verbose)
     })
 }

package/src/commands/DevCommand.ts

@@ -14,6 +14,7 @@ export const DEFAULT_INCLUDES = [
   'pb_*/**/*',
   `package.json`,
   `bun.lockb`,
+  `bun.lock`,
   `patches`,
   `patches/**/*`,
 ]
@@ -40,6 +41,8 @@ export const watchAndDeploy = async (
     )
   }
   console.log(`Dev mode`)
+  await ensureLoggedIn()
+
   const { include, exclude, verbose } = options
   // console.log({ include, exclude })
 
@@ -81,7 +84,9 @@ export const watchAndDeploy = async (
     },
   })
   console.log(
-    `Watching for changes in ${include.join(', ')} and excluding ${exclude.join(', ')}`
+    `Watching for changes in ${include.join(', ')} and excluding ${exclude.join(
+      ', '
+    )}`
   )
   const handle = (path: string, details: any) => {
     upload()
@@ -103,7 +108,7 @@ export async function deployMyCode(
   const args: IFtpDeployArguments = {
     server: 'ftp.pockethost.io',
     username: `__auth__`,
-    password: client.authStore.token,
+    password: client.authStore.exportToCookie(),
     'server-dir': `${instanceName}/`,
     include,
     exclude: [...excludeDefaults, ...exclude],

package/src/commands/ListCommand.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander'
+import { ensureLoggedIn } from '../lib/ensureLoggedIn'
 import { getClient } from './../lib/getClient'
 import { InstanceFields } from './../lib/InstanceFields'
 
@@ -7,6 +8,7 @@ export const ListCommand = () => {
     .alias(`ls`)
     .description(`List all the logs`)
     .action(async () => {
+      await ensureLoggedIn()
       const client = await getClient()
       const instances = await client
         .collection(`instances`)

package/src/commands/LoginCommand.ts

@@ -33,10 +33,7 @@ export const loginWithUserInput = async () => {
     try {
       const authStore = await login(email, pw)
 
-      config(`auth`, {
-        token: authStore.exportToCookie(),
-        record: authStore.model,
-      })
+      config(`pb_auth`, authStore.exportToCookie())
     } catch (e) {
       console.error(
         `There was an error logging in. Please try again or go to https://pockethost.io to reset your password. (${e})`

package/src/commands/LogoutCommand.ts

@@ -0,0 +1,13 @@
+import { Command } from 'commander'
+import { config } from '../lib/config'
+
+export const logout = async () => {
+  config(`pb_auth`, '')
+  console.log(`Logged out!`)
+}
+
+export const LogoutCommand = () =>
+  new Command('logout')
+    .description(`Log out of PocketHost`)
+    .helpOption(false)
+    .action(logout)

package/src/commands/LogsCommand.ts

@@ -1,8 +1,8 @@
 import { fetchEventSource } from '@sentool/fetch-event-source'
 import { Command } from 'commander'
-import { config } from '../lib/config'
 import { savedInstanceName } from '../lib/defaultInstanceId'
 import { ensureLoggedIn } from '../lib/ensureLoggedIn'
+import { getClient, getInstanceBySubdomainCnameOrId } from '../lib/getClient'
 
 export enum StreamNames {
   StdOut = 'stdout',
@@ -15,72 +15,192 @@ export type InstanceLogFields = {
   stream: StreamNames
 }
 
+type EventSourceMessage = {
+  data: InstanceLogFields | null
+}
+
 type Unsubscribe = () => void
 
+/**
+ * Watches instance logs and streams them to the provided update callback
+ *
+ * @param instanceName - The instance ID or subdomain to watch logs for
+ * @param update - Callback function that will receive log entries
+ * @param nInitial - Number of initial log entries to fetch
+ * @returns A tuple with [promise that resolves when streaming ends, function to unsubscribe]
+ */
 const watchInstanceLog = async (
-  instanceId: string,
+  instanceName: string,
   update: (log: InstanceLogFields) => void,
   nInitial = 100
-): Promise<Unsubscribe> => {
+): Promise<[Promise<void>, Unsubscribe]> => {
   const controller = new AbortController()
   const signal = controller.signal
+  let isAborting = false
+  let retryTimeout: ReturnType<typeof setTimeout> | null = null
 
   await ensureLoggedIn()
+  const client = await getClient()
 
-  const continuallyFetchFromEventSource = () => {
-    const url = `https://${instanceId}.pockethost.io/logs`
-    const body = {
-      instanceId,
-      n: nInitial,
-      auth: config(`auth`)!.token,
-    }
+  try {
+    await getInstanceBySubdomainCnameOrId(instanceName)
+  } catch (e) {
+    throw new Error(`Instance "${instanceName}" not found.`)
+  }
 
-    fetchEventSource(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      openWhenHidden: true,
-      body: JSON.stringify(body),
-      onmessage: (event: any) => {
-        const { data } = event
-        if (!data) return
-        update(data)
-      },
-      onopen: async (response: Response) => {
-        // console.log(response)
-      },
-      onerror: (e: Error) => {
-        setTimeout(continuallyFetchFromEventSource, 100)
-      },
-      onclose: () => {
-        console.log(`closed`)
-        setTimeout(continuallyFetchFromEventSource, 100)
-      },
-      signal,
-    })
+  // Function to clear any pending timeouts
+  const clearPendingTimeouts = () => {
+    if (retryTimeout) {
+      clearTimeout(retryTimeout)
+      retryTimeout = null
+    }
   }
-  continuallyFetchFromEventSource()
 
-  return () => {
+  // Create promise that will resolve when streaming ends
+  const streamingPromise = new Promise<void>((resolve, reject) => {
+    const continuallyFetchFromEventSource = () => {
+      // Don't attempt to reconnect if we're aborting
+      if (isAborting) {
+        resolve()
+        return
+      }
+
+      const url = `https://${instanceName}.pockethost.io/logs`
+      const body = {
+        instanceId: instanceName,
+        n: nInitial,
+        auth: client.authStore.exportToCookie(),
+      }
+
+      fetchEventSource(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        openWhenHidden: true,
+        body: JSON.stringify(body),
+        onmessage: (event: EventSourceMessage) => {
+          const { data } = event
+          if (!data || isAborting) return
+          update(data)
+        },
+        onopen: async (response: Response) => {
+          if (!response.ok) {
+            const error = `Failed to open log stream: ${response.status} ${response.statusText}`
+            reject(new Error(error))
+          }
+        },
+        onerror: (e: Error) => {
+          if (isAborting) return
+          console.error(`Log stream error: ${e}`)
+
+          // Clear any existing timeout before setting a new one
+          clearPendingTimeouts()
+          retryTimeout = setTimeout(continuallyFetchFromEventSource, 100)
+        },
+        onclose: () => {
+          if (isAborting) return
+          console.log(`Log stream closed. Reconnecting...`)
+
+          // Clear any existing timeout before setting a new one
+          clearPendingTimeouts()
+          retryTimeout = setTimeout(continuallyFetchFromEventSource, 100)
+        },
+        onabort: () => {
+          console.log(`Log stream aborted`)
+          clearPendingTimeouts()
+          resolve()
+        },
+        signal,
+      })
+    }
+
+    // Start the initial connection
+    continuallyFetchFromEventSource()
+  })
+
+  // Create clean-up function
+  const unsubscribe = () => {
+    isAborting = true
+    clearPendingTimeouts()
     controller.abort()
   }
+
+  // Add cleanup logic to run when promise completes
+  const wrappedPromise = streamingPromise
+    .catch((error) => {
+      unsubscribe()
+      throw error
+    })
+    .finally(() => {
+      clearPendingTimeouts()
+    })
+
+  return [wrappedPromise, unsubscribe]
 }
 
+/**
+ * Creates the logs command
+ */
 export const LogsCommand = () => {
   return new Command('logs')
-    .description(`Tail instance logs`)
+    .description('Tail instance logs')
     .argument('[instance]', 'Instance ID', savedInstanceName())
-    .action((instance) => {
-      watchInstanceLog(instance, (log) => {
-        const { time, message, stream } = log
-        if (stream === 'stderr') {
-          console.error(`[${time}] ${message}`)
-        } else {
-          console.log(`[${time}] ${message}`)
-        }
-      }).catch((e) => {
-        console.error(`Error fetching logs`, e)
-      })
+    .option(
+      '-n, --lines <number>',
+      'Number of initial log lines to show',
+      '100'
+    )
+    .action(async (instance, options) => {
+      let running = true
+      const nInitial = parseInt(options.lines, 10)
+
+      // Set up signal handling before starting stream
+      const cleanup = () => {
+        running = false
+        console.log('\nStopping log streaming...')
+
+        // We'll set this before unsubscribe is defined, but it will be assigned
+        // immediately after watchInstanceLog completes
+        if (unsubscribe) unsubscribe()
+      }
+
+      // Handle termination signals
+      const signals: NodeJS.Signals[] = ['SIGINT', 'SIGTERM', 'SIGHUP']
+      signals.forEach((signal) => process.on(signal, cleanup))
+
+      // Declare unsubscribe variable that will be defined after watchInstanceLog
+      let unsubscribe: Unsubscribe | undefined
+
+      try {
+        // Start watching logs
+        const [streamPromise, unsubscribeFn] = await watchInstanceLog(
+          instance,
+          (log) => {
+            // Only process logs if we're still running
+            if (!running) return
+
+            const { time, message, stream } = log
+            if (stream === StreamNames.StdErr) {
+              console.error(`[${time}] ${message}`)
+            } else {
+              console.log(`[${time}] ${message}`)
+            }
+          },
+          nInitial
+        )
+
+        // Store unsubscribe function for use in cleanup
+        unsubscribe = unsubscribeFn
+
+        // Wait for the streaming to end naturally (should only happen on abort)
+        await streamPromise
+      } catch (err) {
+        cleanup()
+        throw err
+      } finally {
+        // Remove signal handlers to prevent memory leaks
+        signals.forEach((signal) => process.removeListener(signal, cleanup))
+      }
     })
 }

package/src/lib/config.ts

@@ -1,11 +1,10 @@
 import fse from 'fs-extra'
-import { type AuthModel } from 'pocketbase'
 import { PHIO_HOME } from './constants'
 
 const { readJSONSync, writeJSONSync } = fse
 export type Config = {
   email: string
-  auth: { record: AuthModel; token: string }
+  pb_auth: string
 }
 export function config<T extends keyof Config>(
   k: T,

package/src/lib/getClient.ts

@@ -2,6 +2,7 @@ import PocketBase from 'pocketbase'
 import { runTasks } from './../lib/Task'
 import { config } from './config'
 import { PHIO_MOTHERSHIP_URL, PHIO_PASSWORD, PHIO_USERNAME } from './constants'
+import { ensureLoggedIn } from './ensureLoggedIn'
 
 let client: PocketBase | undefined
 export const getClient = async () => {
@@ -21,31 +22,25 @@ export const getClient = async () => {
     }
   }
 
-  const authStore = config('auth')
-  if (authStore) {
-    const { record, token } = authStore
-    client.authStore.loadFromCookie(token)
+  const cookie = config('pb_auth')
+  if (cookie) {
+    client.authStore.loadFromCookie(cookie)
     // console.log({ valid: client.authStore.isValid })
     client.authStore.onChange((token, record) => {
       if (!client) {
         console.warn('No client found - please report this bug')
         return
       }
-      config('auth', {
-        token: client.authStore.exportToCookie(),
-        record: client.authStore.model,
-      })
+      config('pb_auth', client.authStore.exportToCookie())
     })
     await client.collection(`users`).authRefresh()
-    config(`auth`, {
-      token: client.authStore.exportToCookie(),
-      record: client.authStore.model,
-    })
+    config(`pb_auth`, client.authStore.exportToCookie())
   }
   return client
 }
 
 export const getInstanceBySubdomainCnameOrId = async (search: string) => {
+  await ensureLoggedIn()
   const client = await getClient()
   return await client
     .collection(`instances`)